StringBuilder is not always faster - Part 1 of 2
How often have you been told to use StringBuilder to concatenate strings in .NET? My guess is often enough. Here is something you may not know about string concatenation: StringBuilder is not always faster. There are already many articles out there that explain the why’s, I am not going to do that here. But I do have some test data for you.
When concatenating three values or less, traditional concatenation is faster (by a very small margin)
This block of code took 1484 milliseconds to run on my PC:
for (int i = 0; i <= 1000000; i++) { // Concat strings 3 times using StringBuilder StringBuilder s = new StringBuilder(); s.Append(i.ToString()); s.Append(i.ToString()); s.Append(i.ToString()); }
And this one, using traditional concatenation, took slightly less time (1344 milliseconds):
for (int i = 0; i <= 1000000; i++) { // Concat strings 3 times using traditional concatenation string s = i.ToString(); s = s + i.ToString(); s = s + i.ToString(); }
The above data suggests that StringBuilder only starts to work faster once the number of concatenations exceed 3.
Building strings from literals
When building a large string from several string literals (such as building a SQL block, or a client side javascript block), use neither traditional concatenation nor StringBuilder. Instead, choose one of the methods below:
+ operator
// Build script block string s = “<script>” + “function test() {” + ” alert(’this is a test’);” + ” return 0;” + “}”;
The compiler concatenates that at compile time. At run-time, that works as fast as a big string literal.
@ string literal
I sometimes use the @ string literal which allows for newlines (I find this syntax is harder to maintain, formatting-wise, than using the + operator):
string s = @”<script> function test() { alert(’this is a test’); return 0; }”;
Both methods above run about 40 times faster than using StringBuilder or traditional string concatenation.
Rules of Thumb
- When concatenating three dynamic string values or less, use traditional string concatenation.
- When concatenating more than three dynamic string values, use StringBuilder.
- When building a big string from several string literals, use either the @ string literal or the inline + operator.
Updated 2007-09-29
I have posted a follow-up article to provide more detailed analysis and to answer some of the questions asked by readers.
posted on September 18th, 2007 at 10:36 am
posted on September 18th, 2007 at 12:00 pm
posted on September 18th, 2007 at 6:38 pm
posted on September 18th, 2007 at 7:04 pm
posted on September 19th, 2007 at 1:46 am
posted on September 21st, 2007 at 4:34 am
posted on September 21st, 2007 at 4:31 pm
posted on September 23rd, 2007 at 3:10 pm
posted on September 23rd, 2007 at 6:26 pm
posted on September 29th, 2007 at 2:19 am
posted on September 29th, 2007 at 2:39 am
posted on September 29th, 2007 at 11:26 pm
posted on March 14th, 2008 at 7:23 am