This article should shed some light on what string interpolation has to do with boxing and unboxing. Furthermore I want to demystify the performance aspect.

String-Interpolation

Imagine the following snippet:

int myNumber = 2;
var myString = $"My number is {myNumber}";

String interpolation allows you to create an "inline" string. The main advantage is, that it's super readable.

The feature itself is just syntactic sugar. That means one step in the compiler chain will lower this term to something understandable. And most of you think "Yeah of course. It will get lowered to string.Format" but that is not always the case.

And here boxing and unboxing comes into play. Boxing means converting a value to the type object. Unboxing is the other way around.

The compiler will do different things depending whether or not boxing is involved.

Let's have a look at this:

string World = "World";
int AgeInBillionYears = 4;
Console.WriteLine($"Hello {World}. You are {AgeInBillionYears} billion years old");

This term will become as suspected:

Console.WriteLine(string.Format("Hello {0}. You are {1} billion years old", World, AgeInBillionYears));

Let's have a look into example two:

Console.WriteLine($"Hello {World}. You are {AgeInBillionYears.ToString()} years old"); 

This term will become

string[] array = new string[5];
array[0] = "Hello ";
array[1] = World;
array[2] = ". You are ";
array[3] = AgeInBillionYears.ToString();
array[4] = " billion years old";
Console.WriteLine(string.Concat(array));

We can see that the compiler uses string.Concat. Why? Well it's quite easy. In our first example we have an integer and in our second example we have a string and if you look at both method definitions it should become clear what happens.

string.Format(string, object) and string.Concat(string[]).

We see that Concat will not use any boxing at all. As the compiler know nows that everything is from type string, it can use the faster version.

Everytime Boxing/Unboxing is involved in string-interpolation the compiler will use string.Format. If you want to play around and want to see it in action head over to Sharplab.io

Let's have a look at performance.

I created a benchmark, check the code here:

public class StringBuilderBenchmark
{
    [Params(2, 10, 50, 100)] public int ConcatSize { get; set; }

    [Benchmark]
    public string ConcatViaStringBuilder()
    {
        var sb = new StringBuilder();
        for (var i = 0; i < ConcatSize; i++)
        {
            sb.Append(i);
        }

        return sb.ToString();
    }

    [Benchmark]
    public string ConcatViaConcatBoxed()
    {
        var output = string.Empty;
        for (var i = 0; i < ConcatSize; i++)
        {
            output += output + i;
        }

        return output;
    }
    
    [Benchmark]
    public string ConcatViaConcatUnboxed()
    {
        var output = string.Empty;
        for (var i = 0; i < ConcatSize; i++)
        {
            output += output + i.ToString();
        }

        return output;
    }
    
    [Benchmark]
    public string ConcatViaStringFormatBoxed()
    {
        var output = string.Empty;
        for (var i = 0; i < ConcatSize; i++)
        {
            output = $"{output}{i}";
        }

        return output;
    }
    
    [Benchmark]
    public string ConcatViaStringFormatUnboxed()
    {
        var output = string.Empty;
        for (var i = 0; i < ConcatSize; i++)
        {
            output = $"{output}{i.ToString()}";
        }

        return output;
    }
}

We have mutliple scenarios: string.Format, string.Concat and a stringbuilder. We will always concatenate them. But once with and once without boxing/unboxing. Plus we'll check for only 2 string and 10 string, 50 and 100.

What we can see is, that StringBuilder makes no sense for a small amount of strings. Please keep in my that we are talking about nanoseconds. But we can see that boxing and unboxing can play a major role in the performance of string concatenation.