addition of strings in c#, how the compiler does it?

Question

A = string.Concat("abc","def") 

B = "abc" + "def"

A vs. B

Lately I have been confused why many would say that definitely A does a much faster processing compared to B. But, the thing is they would just say because somebody said so or because it is just the way it is. I suppose I can hear a much better explaination from here.

How does the compiler treats these strings?

Thank you!

Answer 1

The very first thing I did when I joined the C# compiler team was I rewrote the optimizer for string concatenations. Good times.

As already noted, string concats of constant strings are done at compile time. Non-constant strings do some fancy stuff:

a + b --> String.Concat(a, b)
a + b + c --> String.Concat(a, b, c)
a + b + c + d --> String.Concat(a, b, c, d)
a + b + c + d + e --> String.Concat(new String[] { a, b, c, d, e })

The benefits of these optimizations are that the String.Concat method can look at all the arguments, determine the sum of their lengths, and then make one big string that can hold all the results.

Here's an interesting one. Suppose you have a method M that returns a string:

s = M() + "";

If M() returns null then the result is the empty string. (null + empty is empty.) If M does not return null then the result is unchanged by the concatenation of the empty string. Therefore, this is actually optimized as not a call to String.Concat at all! It becomes

s = M() ?? ""

Neat, eh?

Answer 2

Read this: The Sad Tragedy of Micro-Optimization Theater (Coding Horror)

Answer 3

In C#, the addition operator for strings is just syntactic sugar for String.Concat. You can verify that by opening the output assembly in reflector.

Another thing to note is, if you have string literals (or constants) in your code, such as in the example, the compiler even changes this to B = "abcdef".

But, if you use String.Concat with two string literals or constants, String.Concat will still be called, skipping the optimization, and so the + operation would actually be faster.

So, to sum it up:

stringA + stringB becomes String.Concat(stringA, stringB).
"abc" + "def" becomes "abcdef"
String.Concat("abc", "def") stays the same

Something else i just had to try:

In C++/CLI, "abc" + "def" + "ghi" is actually translated to String.Concat(String.Concat("abc", "def"), "ghi")