ansaurus

Question

Converting a List<int> to a comma separated list

Answer 1

+10 A:

List<int> list = ...;
string.Join(",", list.Select(n => n.ToString()).ToArray())

Pavel Minaev 2009-10-06 23:46:32

Clever but slow and bloated, as it allocates one string per element. Using a StringBuilder would be much more efficient.

Steven Sudit 2009-10-06 23:49:01

From what I saw online(quick search) String.Join is faster than using a StringBuilder.

Yuriy Faktorovich 2009-10-06 23:51:19

http://stackoverflow.com/questions/585860/string-join-vs-stringbuilder-which-is-faster, you are incorrect Steven

Yuriy Faktorovich 2009-10-06 23:53:20

I think Steven is referring to the n.ToString() part rather than the String.Join.

Larsenal 2009-10-06 23:53:28

Larsenal: but StringBuilder.Append(Int32) internally calls ToString on the integer anyway. StringBuilder doesn't magically avoid the cost of allocating a string for each element; it just tucks it nicely out of sight.

itowlson 2009-10-07 00:03:56

@itowlson: Good point, although it still has to keep expanding the array, which means allocating a new one and copying it over.

Steven Sudit 2009-10-07 00:21:26

@Adam: Even taking itowlson's point, it remains the case that a loop with StringBuilder is going to be faster.

Steven Sudit 2009-10-07 00:22:00

@Steven: Read the link, StringBuilder isn't going to be faster.

Yuriy Faktorovich 2009-10-07 01:27:06

@Yuriy, I read the link, including the part where Skeet says "if you already have an array of strings to concatenate together (with a delimiter), String.Join is the fastest way of doing it." That "if" is the issue. While Join is well-optimized and even bypasses some of the overhead of StringBuilder, creating the array of strings in the first place has its own costs, including the need to copy over with each doubling. Which one is faster in practice is going to depend heavily on whether it's just a couple of numbers or many. From what I see, the latter should favor StringBuilder.

Steven Sudit 2009-10-07 13:34:43

@Steven: I'm getting strange benchmarking results. I used cdiggins method for the StringBuilder, unless you want to write your own. It turned out for larger arrays the StringBuilder wins, but for shorter ones it depends on how many times it is run(LINQ wins for shorter arrays run many times). But altogether it looks like you are correct in this case the StringBuilder worked faster.

Yuriy Faktorovich 2009-10-07 14:05:50

@Yuriy: That's interesting. One possibility is what I said above regarding array doubling, but then again, cdiggins suffers from the same problem on the StringBuilder side. Maybe String.Join's optimization of precalculating total length runs afoul of cache limitations. Either way, I was clearly wrong in the first place about StringBuilder being "much" faster, since I didn't take into account the unnecessary temporary string inside StringBuilder.Append(int). The two methods are both acceptable, although a properly-tuned StringBuilder.Append solution has a slight advantage on large arrays.

Steven Sudit 2009-10-07 17:36:06

Answer 2

+4 A:

List<int> list = new List<int> { 1, 2, 3 };
Console.WriteLine(String.Join(",", list.Select(i => i.ToString()).ToArray()));

Yuriy Faktorovich 2009-10-06 23:47:43

Answer 3

+1 A:

My "clever" entry:

        List<int> list = new List<int> { 1, 2, 3 };
        StringBuilder sb = new StringBuilder();
        var y = list.Skip(1).Aggregate(sb.Append(x.ToString()),
                    (sb1, x) =>  sb1.AppendFormat(",{0}",x));

        // A lot of mess to remove initial comma
        Console.WriteLine(y.ToString().Substring(1,y.Length - 1));

Just haven't figured how to conditionally add the comma.

Larsenal 2009-10-07 00:01:17

Please don't write `Select` with side effects in the lambda. In this case you aren't even using `y`, so your `Select` is essentially just a `foreach` - so write it as such.

Pavel Minaev 2009-10-07 00:05:45

I wasn't suggesting this as a good solution. OP wanted something more interesting than foreach.

Larsenal 2009-10-07 00:07:06

Yeah, but abusing `Select` as `foreach` goes past "interesting" and into, well, "abuse". A more interesting approach here would be to use `Enumerable.Aggregate` with `StringBuilder` as a seed value - try that.

Pavel Minaev 2009-10-07 00:09:32

Good idea. I have to step out, but I may give that a whirl.

Larsenal 2009-10-07 00:10:03

Answer 4

+1 A:

For extra coolness I would make this an extension method on IEnumerable<T> so that it works on any IEnumerable:

public static class IEnumerableExtensions {
  public static string BuildString<T>(this IEnumerable<T> self, string delim) {
    return string.Join(",", list.Select(x => x.ToString()).ToArray())        
  }
}

Use it as follows:

List<int> list = new List<int> { 1, 2, 3 };
Console.WriteLine(list.BuildString(", "));

cdiggins 2009-10-07 00:14:08

Two possible optimizations: 1) Append the delimeter after each item regardless, then remove the extra one after the loop ends. 2) Specify a capacity for the StringBuilder.

Steven Sudit 2009-10-07 01:05:42

If you dig out Reflector, it turns out that Join sums up the lengths to precalculate the buffer size, and also "primes the pump" by appending the first string outside the loop, and then, inside the loop, unconditionally appending the delimiter before the next string. Combined with some unsafe/internal tricks, it should be very fast.

Steven Sudit 2009-10-07 13:36:36

@Steven: followed your advice.

cdiggins 2009-10-19 16:43:17

Hope it worked out well for you.

Steven Sudit 2009-10-20 21:01:19

Answer 5

+4 A:

For approximately one gazillion solutions to a slightly more complicated version of this problem -- many of which are slow, buggy, or don't even compile -- see the comments to my article on this subject:

http://blogs.msdn.com/ericlippert/archive/2009/04/15/comma-quibbling.aspx

and the StackOverflow commentary:

http://stackoverflow.com/questions/788535/eric-lipperts-challenge-comma-quibbling-best-answer

Eric Lippert 2009-10-07 05:33:45

Thanks for the link. This string concatenation problem has turned out to be more complex, and more educational, than I had expected!

Steven Sudit 2009-10-07 17:38:54

Answer 6

A:

Seems reasonablly fast.

IList<int> listItem = Enumerable.Range(0, 100000).ToList();
var result = listItem.Aggregate<int, StringBuilder, string>(new StringBuilder(), (strBuild, intVal) => { strBuild.Append(intVal); strBuild.Append(","); return strBuild; }, (strBuild) => strBuild.ToString(0, strBuild.Length - 1));

Gregory 2009-10-07 06:15:35

ansaurus

tags:

views:

answers:

Converting a List<int> to a comma separated list

related questions