Reputation: 8269
I was wondering about StringBuilder and I've got a question that I was hoping the community would be able to explain.
Let's just forget about code readability, which of these is faster and why?
StringBuilder.Append
:StringBuilder sb = new StringBuilder();
sb.Append(string1);
sb.Append("----");
sb.Append(string2);
StringBuilder.AppendFormat
:StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}----{1}",string1,string2);
Upvotes: 44
Views: 62324
Reputation: 672
In C# 10/.NET 6+, both the code examples compile down to the same code, due to the new interpolated string handlers built into the compiler. In fact, all of these produce equivalent compiled code:
sb.Append(string1);
sb.Append("----");
sb.Append(string2);
sb.AppendFormat("{0}----{1}",string1,string2);
sb.Append($"{string1}----{string2}");
Because of that, you can go with whatever is most readable.
Upvotes: 0
Reputation: 3250
Faster is 1 in your case however it isn't a fair comparison. You should ask StringBuilder.AppendFormat()
vs StringBuilder.Append(string.Format())
- where the first one is faster due to internal working with char array.
Your second option is more readable though.
Upvotes: 0
Reputation: 74560
It's impossible to say, not knowing the size of string1
and string2
.
With the call to AppendFormat
, it will preallocate the buffer just once given the length of the format string and the strings that will be inserted and then concatenate everything and insert it into the buffer. For very large strings, this will be advantageous over separate calls to Append
which might cause the buffer to expand multiple times.
However, the three calls to Append
might or might not trigger growth of the buffer and that check is performed each call. If the strings are small enough and no buffer expansion is triggered, then it will be faster than the call to AppendFormat
because it won't have to parse the format string to figure out where to do the replacements.
More data is needed for a definitive answer
It should be noted that there is little discussion of using the static Concat
method on the String
class (Jon's answer using AppendWithCapacity
reminded me of this). His test results show that to be the best case (assuming you don't have to take advantage of specific format specifier). String.Concat
does the same thing in that it will predetermine the length of the strings to concatenate and preallocate the buffer (with slightly more overhead due to looping constructs through the parameters). It's performance is going to be comparable to Jon's AppendWithCapacity
method.
Or, just the plain addition operator, since it compiles to a call to String.Concat
anyways, with the caveat that all of the additions are in the same expression:
// One call to String.Concat.
string result = a + b + c;
NOT
// Two calls to String.Concat.
string result = a + b;
result = result + c;
For all those putting up test code
You need to run your test cases in separate runs (or at the least, perform a GC between the measuring of separate test runs). The reason for this is that if you do say, 1,000,000 runs, creating a new StringBuilder
in each iteration of the loop for one test, and then you run the next test that loops the same number of times, creating an additional 1,000,000 StringBuilder
instances, the GC will more than likely step in during the second test and hinder its timing.
Upvotes: 49
Reputation: 416131
Of course profile to know for sure in each case.
That said, I think in general it will be the former because you aren't repeatedly parsing the format string.
However, the difference would be very small. To the point that you really should consider using AppendFormat
in most cases anyway.
Upvotes: 1
Reputation: 8159
StringBuilder
also has cascaded appends: Append()
returns the StringBuilder
itself, so you can write your code like this:
StringBuilder sb = new StringBuilder();
sb.Append(string1)
.Append("----")
.Append(string2);
Clean, and it generates less IL-code (although that's really a micro-optimization).
Upvotes: 2
Reputation: 1503489
casperOne is entirely accurate that it depends on the data. However, suppose you're writing this as a class library for 3rd parties to consume - which would you use?
One option would be to get the best of both worlds - work out how much data you're actually going to have to append, and then use StringBuilder.EnsureCapacity to make sure we only need a single buffer resize.
If I weren't too bothered though, I'd use Append
x3 - it seems "more likely" to be faster, as parsing the string format tokens on every call is clearly make-work.
Note that I've asked the BCL team for a sort of "cached formatter" which we could create using a format string and then re-use repeatedly. It's crazy that the framework has to parse the format string each time it's used.
EDIT: Okay, I've edited John's code somewhat for flexibility and added an "AppendWithCapacity" which just works out the necessary capacity first. Here are the results for the different lengths - for length 1 I used 1,000,000 iterations; for all other lengths I used 100,000. (This was just to get sensible running times.) All times are in millis.
Unfortunately tables don't really work in SO. The lengths were 1, 1000, 10000, 20000
Times:
So as it happened, I never saw AppendFormat beat Append - but I did see AppendWithCapacity win by a very substantial margin.
Here's the full code:
using System;
using System.Diagnostics;
using System.Text;
public class StringBuilderTest
{
static void Append(string string1, string string2)
{
StringBuilder sb = new StringBuilder();
sb.Append(string1);
sb.Append("----");
sb.Append(string2);
}
static void AppendWithCapacity(string string1, string string2)
{
int capacity = string1.Length + string2.Length + 4;
StringBuilder sb = new StringBuilder(capacity);
sb.Append(string1);
sb.Append("----");
sb.Append(string2);
}
static void AppendFormat(string string1, string string2)
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}----{1}", string1, string2);
}
static void Main(string[] args)
{
int size = int.Parse(args[0]);
int iterations = int.Parse(args[1]);
string method = args[2];
Action<string,string> action;
switch (method)
{
case "Append": action = Append; break;
case "AppendWithCapacity": action = AppendWithCapacity; break;
case "AppendFormat": action = AppendFormat; break;
default: throw new ArgumentException();
}
string string1 = new string('x', size);
string string2 = new string('y', size);
// Make sure it's JITted
action(string1, string2);
GC.Collect();
Stopwatch sw = Stopwatch.StartNew();
for (int i=0; i < iterations; i++)
{
action(string1, string2);
}
sw.Stop();
Console.WriteLine("Time: {0}ms", (int) sw.ElapsedMilliseconds);
}
}
Upvotes: 14
Reputation: 63495
casperOne is correct. Once you reach a certain threshold, the Append()
method becomes slower than AppendFormat()
. Here are the different lengths and elapsed ticks of 100,000 iterations of each method:
Append() - 50900
AppendFormat() - 126826
Append() - 1241938
AppendFormat() - 1337396
Append() - 12482051
AppendFormat() - 12740862
Append() - 61029875
AppendFormat() - 60483914
When strings with a length near 20,000 are introduced, the AppendFormat()
function will slightly outperform Append()
.
Why does this happen? See casperOne's answer.
Edit:
I reran each test individually under Release configuration and updated the results.
Upvotes: 27
Reputation: 351698
Append
will be faster in most cases because there are many overloads to that method that allow the compiler to call the correct method. Since you are using Strings
the StringBuilder
can use the String
overload for Append
.
AppendFormat
takes a String
and then an Object[]
which means that the format will have to be parsed and each Object
in the array will have to be ToString'd
before it can be added to the StringBuilder's
internal array.
Note: To casperOne's point - it is difficult to give an exact answer without more data.
Upvotes: 6
Reputation: 116180
1 should be faster becuase it's simply appending the strings whereas 2 has to create a string based on a format and then append the string. So there's an extra step in there.
Upvotes: 0
Reputation: 2750
I'd assume it was the call that did the least amount of work. Append just concatenates strings, where AppendFormat is doing string substitutions. Of course these days, you never can tell...
Upvotes: 0