Performance difference between C# 6.0 "string" and $"string"

Question

I have 2 codes in C# 6.0:

Sample 1:

string bar;
// ... some code setting bar.
var foo =
    "Some text, " +
    $"some other {bar}, " +
    "end text.";

Sample 2:

string bar;
// ... some code setting bar.
var foo =
    $"Some text, " +
    $"some other {bar}, " +
    $"end text.";

Obviously both codes generate the same result regardless of aesthetic differences.

Question:
Is there a performance difference between both? In other words, are both cases compiled to the same?

EDIT:
Some important comments was posted that I find useful to replay to make a clarification of the topic in this question.

The second one is horrible. Don't use the string interpolation symbol ($) on strings that aren't interpolated. It will be confusing for anyone else looking at the code (or future, more experienced you)

Thanks for the tip, it's very appreciated, although I have to argue that what you said is a aesthetic argumentation. Even this code been as ugly as you said, even if should never been used, I still think is useful discuss possible performances differences that It MAY generated.

@communityMember1: It doesn't affect performance of the code at runtime.
@communityMember2: That is not true. Interpolated string is syntactic sugar for calling string.Format, which has to be called (and thus affecting performance).

Maybe to avoid further discussion, we should reinforce the answers and comments based on some documentation or even an empirical proof (like the result of a compilation).

Answer 1

The $ creates an interpolated string which is the same as using String.Format. If you use + with string literals then the compiler optimizes the code to avoid concatenation all together. The use of interpolated strings might prevent this optimization.

Edit

---

Performance and Literal Optimization Test

Ok, well I just tested this and there doesn't seem to be any performance issue. Apparently the compiler ignores $ and doesn't use String.Format if no {} are present. My test results are shown below for 6 million loops of constructing a 50 length string.

• String.Format: 23700 ms
• $"a{null}" with + : 22650 ms
• $"a" with + : 13 ms
• "a" with +: 13 ms
• "a" concatenated with +: 700 ms

Also, there's no difference looking at the IL. So performance wise, the code you posted is executed and optimized the same, the $ gets ignored and is only a factor when {} are used.

Syntax

Of course there can be debate about if that is good syntax or not. I can think of arguments for and against.

Pros

• It's easier to add a new argument if $ is already present
• It's easier to move an argument between lines of a multi-line literal
• It provides consistency between lines of a multi-line literal

Cons

• It looks different... principal of least astonishment.
• Why add syntax that isn't being used?
• It doesn't make the inserted variable obvious

For me, the tilting point is that I see $ and expect to see a {} and an argument. It causes cognitive dissonance if I don't see what I expect to see. On the other hand, I can imagine situations where the fluidity it provides might out way this. It's probably far to say it depends on the development group and objectives.

Answer 2

Look at the IL:

First code:

var bar = "a";
var foo = "b" + $"{bar}";

First IL:

IL_0000:  nop         
IL_0001:  ldstr       "a"
IL_0006:  stloc.0     // bar
IL_0007:  ldstr       "b"
IL_000C:  ldstr       "{0}"
IL_0011:  ldloc.0     // bar
IL_0012:  call        System.String.Format
IL_0017:  call        System.String.Concat
IL_001C:  stloc.1     // foo
IL_001D:  ret         

Second code:

var bar = "a";
var foo = $"b" + $"{bar}";

Second IL:

IL_0000:  nop         
IL_0001:  ldstr       "a"
IL_0006:  stloc.0     // bar
IL_0007:  ldstr       "b"
IL_000C:  ldstr       "{0}"
IL_0011:  ldloc.0     // bar
IL_0012:  call        System.String.Format
IL_0017:  call        System.String.Concat
IL_001C:  stloc.1     // foo
IL_001D:  ret         

Conclusion:

There is no compiled differences between the both codes.

PS: (IL generated by Linqpad 5.22.02).

Answer 3

This was pretty easy to do some simple diagnostics with. Maccettura shows in the comment that that there is no difference when it gets compiled as it only called String.Format once for each string regardless of the extra interpolation but this test will back it up as well.

int rounds = 50;
int timesToCreateString = 50000;
Stopwatch sw = new Stopwatch();
double first = 0;
double second = 0;
for (int i = 0; i < rounds; i++)
{
    sw.Start();
    for (int bar = 0; bar < timesToCreateString; bar++)
    {
        var foo = "Some text, " +
                 $"some other {bar}, " +
                  "end text.";
    }
    sw.Stop();
    first += sw.ElapsedTicks;
    sw.Reset();
    sw.Start();
    for (int bar = 0; bar < timesToCreateString; bar++)
    {                
        var foo = $"Some text, " +
                  $"some other {bar}, " +
                  $"end text.";
    }
    sw.Stop();
    second += sw.ElapsedTicks;
    sw.Reset();
}
Console.WriteLine("Average first test: " + first / rounds);
Console.WriteLine("Average second test: " + second / rounds);
Console.ReadKey();
// program ran 3 times and results.
//Average first test: 54822.04
//Average second test: 55083.86

//Average first test: 54317.66
//Average second test: 54807.8

//Average first test: 49873.12
//Average second test: 48264.36

Answer 4

You can choose whatever you like. It is true the $ translates to string.format (see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/interpolated-strings ) but the compiler is smart enough to filter out code that isn't formatted.