For instance, does the compiler know to translate
string s = "test " + "this " + "function";
to
string s = "test this function";
and thus avoid the performance hit with the string concatenation?
Does C# optimize the concatenation of string literals?
Viewed 8214
7 Answers
Yes. This is guaranteed by the C# specification. It's in section 7.18 (of the C# 3.0 spec):
Whenever an expression fulfills the requirements listed above, the expression is evaluated at compile-time. This is true even if the expression is a sub-expression of a larger expression that contains non-constant constructs.
(The "requirements listed above" include the + operator applied to two constant expressions.)
See also this question.
Just a side note on a related subject - the C# compiler will also 'optimize' multiple concatenations involving non-literals using the '+' operator to a single call to a multi-parameter overload of the String.Concat() method.
So
string result = x + y + z;
compiles to something equivalent to
string result = String.Concat( x, y, z);
rather than the more naive possibility:
string result = String.Concat( String.Concat( x, y), z);
Nothing earth-shattering, but just wanted to add this bit to the discussion about string literal concatenation optimization. I don't know whether this behavior is mandated by the language standard or not.
Yes.
C# not only optimizes the concatenation of string literals, it also collapses equivalent string literals into constants and uses pointers to reference all references to the same constant.
From the horses mouth:
Concatenation is the process of appending one string to the end of another string. When you concatenate string literals or string constants by using the + operator, the compiler creates a single string. No run time concatenation occurs. However, string variables can be concatenated only at run time. In this case, you should understand the performance implications of the various approaches.
I had a similar question, but about VB.NET instead of C#. The simplest way of verifying this was to view the compiled assembly under Reflector.
The answer was that both the C# and VB.NET compiler optimise concatenation of string literals.
I believe the answer to that is yes, but you'd have to look at what the compiler spits out ... just compile, and use reflector on it :-)
Related