Constructing big strings (e.g. for SQL commands) how smart is the C# compiler?

Question

Hi. This may sound stupid but...

When I create big SQL commands I want to keep my code readable and I do this:

cmd.CommandText = "SELECT top 10 UserID, UserName " +
 "FROM Users " +
 "INNER JOIN SomeOtherTable ON xxxxx " +
 "WHERE UserID IN (blablabla)";

See the concatenations? Now, to save performance I now do this:

cmd.CommandText = @"SELECT top 10 UserID, UserName
     FROM Users
     INNER JOIN SomeOtherTable ON xxxxx
     WHERE UserID IN (blablabla)";

It keeps the code readable but saves concatenations. Now does it really save any performance or the compiler is smart enough to "pre-concatenate" the first string?

Answer 1

I suspect that it will all get pre concatenated anyway but an easy way to tell would be to compile a small console Application doing this type of concatenation then have a look at it with .NET reflector.

Answer 2

Yes the compiler is smart enough to optimize constant string concatenations. To prove this let's examine the following method:

public static string Concat()
{
    return "a" + "b";
}

Compiled in Release mode this produces the following IL:

.method public hidebysig static string Concat() cil managed
{
    .maxstack 8
    L_0000: ldstr "ab"
    L_0005: ret 
}

Notice the optimization. So in terms of performance both methods are identical. The only difference is that in the second case you will get new lines (\r\n) in the string, so they won't produce the exactly same string but SQL Server is also smart enough :-)

Answer 3

Yes, the compiler will compute arithemetical operations on constant numbers and strings at compile time. However, the better way to answer performance questions like this is to try it yourself. Get out the StopWatch class, write the code both ways, run it a billion times in a loop, and then you'll know.