String Concatenation Vs String Builder Append

Question

So...I have this scenario where I have a Foreach loop that loops through a List of Checkboxes to check which are selected. For every selected checkbox, I have to do a pretty long string concatenation, involving 30 different strings of an average length of 20 characters, and then send it out as a HTTP request. 2 of the strings are dependant on the index/value of the checkbox selected.

The length of the List of Checkboxes is also variable depending upon the user's data. I would say the average length of the List would be 20, but it can go up to 50-60. So the worst case scenario would be performing the whole string concatenation 60 or so times.

For now I'm doing it with simple string concatenation via the '+' operator, but I'm wondering if it would be faster to do it with Stringbuilder. Of course, that means I'd have to either create a Stringbuilder object within the loop, or create it before the loop and call Stringbuilder.Remove at the end of it after sending out the HTTP request.

I appreciate any insights anybody can share regarding this issue.

EDIT
Thanks for all the replies everybody, so from what I've gathered, the best way for me to go about doing this would be something like:

 StringBuilder sb = new StringBuilder();
 foreach (CheckBox item in FriendCheckboxList)
 {
     if (item.Checked)
     {
         sb.Append(string1);
         sb.Append(string2);
         sb.Append(string3);
         .
         .
         .
         sb.Append(stringLast);

         SendRequest(sb.ToString());
         sb.Length = 0;
      }
  }

Answer 1

Use StringBuilder. That's what it's for.

Strings are immutable. String concatenation creates a new string, needing more memory, and is generally considered slow:

string a = "John" + " " + "Saunders";

This creates a string "John ", then creates another string "John Saunders", then finally, assigns that to "a". The "John " is left for garbage collection.

string a = "John";
a += " ";
a += "Saunders";

This is about the same, as "John" is replaced by a new string "John ", which is replaced by a new string "John Saunders". The originals are left to be garbage collected.

On the other hand, StringBuilder is designed to be appended, removed, etc.

---

Example:

StringBuilder sb = new StringBuilder();
for (int i=0; i<n; i++)
{
    sb.Length = 0;
    sb.Append(field1[i]);
    sb.Append(field2[i]);
    ...
    sb.Append(field30[i]);
    // Do something with sb.ToString();
}

Answer 2

This topic has been analysed to death over the years. The end result is that if you are doing a small, known number of concatenations, use '+', otherwise use stringbuilder. From what you've said, concatenate with '+' should be faster. There are a gazillion (give or take) sites out there analysing this - google it.

For the size of string you are talking about, it's negligible anyway.

EDIT: on second thought, SB is probably faster. But like I said, who cares?

Answer 3

I know this has been answered, but I wanted to point out that I actually think the "blindly accepted as gospel" approach of always using StringBuilder is sometimes wrong, and this is one case.

For background, see this blog entry: Link

The short of it is, for this particular case, as described, you will see better performance by avoiding StringBuilder and making use of the + operator thusly:

foreach (CheckBox item in FriendCheckboxList)
{
    if (item.Checked)
    {
        string request = string1 +
            string2 +
            string3 +
            .
            .
            .
           stringLast;
        SendRequest(request);
    }
}

The reason is that the C# compiler (as of .NET 1.1), will convert that statement into a single IL call to String.Concat passing an array of Strings as an argument. The blog entry does an excellent job outlining the implementation details of String.Concat, but suffice to say, it is extremely efficient for this case.

Answer 4

In general I would recommend to use a StringBuilder.

Have you tested this and checked the performance? Is the performance an issue vs how long it will take you to rewrite the code?

Answer 5

If your asking this question, chances are you should use StringBuilder for many reasons, but i'll provide two.

1. When you use string concatenation it has to allocate a new buffer and and copy the data in the other string into the new string variable. So you are going to incur many repeated allocations. Which in the end ends up fragmenting the memory, using up heap space, and making more work for the Garbage collector. The StringBuilder on the other hand pre-allocates a buffer and as you add strings to it doesn't need to keep re-allocating (assuming initial buffer is large enough). Which increases performance and is far less taxing on memory.

2. As developers we should try to anticipate future growth. Let's say that your list grows substantially over time and then all of a sudden starts performing slowly. If you can prevent this with little effort now, why wouldn't you do it?