Both
String and
StringBuilder are classes used to handle strings.
The most common operation with a string is concatenation. This activity has to be performed very efficiently. When we use the "String" object to concatenate two strings, the first string is combined to the other string by creating a new copy in the memory as a string object, and then the old string is deleted. This process is a little long. Hence we say "
Strings are immutable".
Simple example: The following will make many programmers cringe with pain:
string s = string.Empty;
for (i = 0; i < 1000; i++) {
s += i.ToString() + " ";
}
You'll end up creating 2001 strings here, of which 2000 are thrown away.
When we make use of the "StringBuilder" object, the
Append method is used. This means, an insertion is done on the existing string. Operation on StringBuilder object is faster than String operations
, as the copy is done to the same location. Usage of StringBuilder is more efficient in case large amounts of string manipulations have to be performed.
The same example using StringBuilder:
StringBuilder sb = new StringBuilder();
for (i = 0; i < 1000; i++) {
sb.Append(i);
sb.Append(' ');
}
This should place much less stress on the memory allocator :-)
It should be noted however, that the C# compiler is reasonably smart when it comes to strings. For example, the following line
string foo = "abc" + "def" + "efg" + "hij";
will be joined by the compiler, leaving only a single string at runtime. Similarly, lines such as
string foo = a + b + c + d + e + f;
will be rewritten to
string foo = string.Concat(a, b, c, d, e, f);
so you don't have to pay for five nonsensical concatenations which would be the naïve way of handling that. This won't save you in loops as above (unless the compiler unrolls the loop but only the JIT may actually do so and better don't bet on that)
