which string operation is better?

Question

Possible Duplicate:
String concatenation vs String Builder. Performance

Any difference (performance and memory usage) between the following two options?

option 1:

StringBuilder msgEntry = new StringBuilder();
msgEntry.AppendLine("<" + timeTag + ">" + timeStamp + "</" + timeTag + ">");

options 2:

StringBuilder msgEntry = new StringBuilder();
msgEntry.Append("<");
msgEntry.Append(timeTag);
msgEntry.Append(">");
msgEntry.Append(timeStamp);
msgEntry.Append("</");
msgEntry.Append(timeTag );
msgEntry.Append(">\n");

Answer 1

The second is possibly slightly better in terms of memory use, because it doesn't need to compute the intermediate string¹... but it's less readable, IMO.

Personally I'd use:

msgEntry.AppendFormat("<{0}>{1}</{0}>", timeTag, timeStamp);

You haven't shown what you want to do with the StringBuilder afterwards. If you're just going to convert it to a string, then I'd use:

string text = string.Format("<{0}>{1}</{0}>", timeTag, timeStamp);

to start with.

What's the performance like? Well, probably worse - after all, it's got to parse the format string. But unless you've measured this and found it to be the bottleneck, why are you worried?

In general:

• Make sure your architecture is reasonably efficient - that's hard to change later.
• Balance your internal design between efficiency and simplicity, with an emphasis on testability; changing the design later may take a while, but it should usually be feasible without compatibility issues.
• Write your implementation to be as readable as possible.
• Measure the system to find out whether it performs well enough, and where the bottlenecks are. They're almost never going to be in code like this. (We're not talking about string concatenation in a loop here, after all.)
• When you've found a bottleneck, try different optimizations and measure them too. Don't assume that something you think will be faster will actually be faster.

---

¹ Or the array to pass to Concat... we don't know the type of timeStamp so we can't tell exactly what's going on there; in the second form it may be appended in-place whereas the first form may need to box it and then convert it to a string before performing the concatenation.

The exact implementation for reallocation etc may well have changed between .NET 3.5 and .NET 4 (I know some bits of the implementation have). Without very careful benchmarking, I'd be really loathe to say which is faster... but the readability is easier to call, albeit subjectively.

Answer 2

In general, StringBuilder... but when you talk about performance, the only real test is measurement. Especially for LOTS of string changes, StringBuilder is definitely the way to go. For a couple strings... it's probably just easier to append them with the + operator.

Answer 3

I would use .AppendFormat(); in that case

StringBuilder msgEntry = new StringBuilder();
msgEntry.AppendFormat("<{0}>{1}</{0}>", timeTag , timeStamp);

Answer 4

Personally, I would choose neither, and use

msgEntry.AppendFormat("<{0}>{1}</{0}>", timeTag, timeStamp);

Answer 5

If that is all you are doing, don't use StringBuilder. It is too much overhead with a readability hit.

Try this:

string.Format("<{0}>{1}</{2}>", timeTag, timeStamp, timeTag);

Answer 6

I have relied on the advice in MSDN's Performance Tips and Tricks in .NET Applications which advises to Use StringBuilder for Complex String Manipulation.

It goes on to advise:

Tradeoffs There is some overhead associated with creating a StringBuilder object, both in time and memory. On a machine with fast memory, a StringBuilder becomes worthwhile if you're doing about five operations. As a rule of thumb, I would say 10 or more string operations is a justification for the overhead on any machine, even a slower one.

I would also consider this advice from a code optimization .Net show:

It is especially important to pre-allocate the size of the string. If you don't, StringBuilder is still faster, but if you can predict the ultimate length of the final string, set it in advance.

That is because the default capacity of a StringBuilder is 16. It automatically resizes when capacity is exceeded -- it doubles every time. So, you may have several unnecessary resizings if you don't set the initial capacity. You can count up the maximum expected number of characters in your example, and initialize the StringBuilder so that it won't resize. That will save some CPU.

And here is some additional advice from MSDN:

The performance of a concatenation operation for a String or StringBuilder object depends on how often a memory allocation occurs. A String concatenation operation always allocates memory, whereas a StringBuilder concatenation operation only allocates memory if the StringBuilder object buffer is too small to accommodate the new data. Consequently, the String class is preferable for a concatenation operation if a fixed number of String objects are concatenated. In that case, the individual concatenation operations might even be combined into a single operation by the compiler. A StringBuilder object is preferable for a concatenation operation if an arbitrary number of strings are concatenated; for example, if a loop concatenates a random number of strings of user input.

Answer 7

The second line is better as your not getting much if any benifit from stringbuilder in the first. However for a small string concat like that I wouldn't bother with stringbuilder

Answer 8

Yes.

If you're going to do option 1, there's no point in using a StringBuilder. You're still doing string concatenation and will end up with multiple extra temp strings being created and discarded in-memory.

For something like this, you should probably use String.Format()

Answer 9

The first example seems wrong to me. What's the point of creating StringBuider object when you are concatenating strings before passing them to the StringBuilder?

Also note that:

• Append returns instance of StringBuilder, so calls to Append and AppendLine can be chained together
• At the end of second example you can use AppendLine(">") instead of Append(">\n")

    StringBuilder msgEntry = new StringBuilder();
    msgEntry.Append("<")
        .Append(timeTag)
        .Append(">")
        .Append(timeStamp)
        .Append("</")
        .Append(timeTag )
        .AppendLine(">");

Personally I'd do

    string.Format("<{0}>{1}</{0}>", timeTag, timeStamp);

unless you need the StringBuilder for something else.

Answer 10

Always use StringBuilder.Append() for string concatenation. The string + operator causes new allocation for each new item.