Question about how string.Format works

[zxcvqwerasdf]

Environment: NET 6, Windows 10, No code optimization
Code:

using System.Diagnostics;
internal class Program
{
    public static void TestMethod()
    {
        for (int i = 0; i < 100000000; i++)
        {
            string tempTest = $"It's test: {i}";
        }
    }
    private static void Main(string[] args)
    {
        Stopwatch st = new Stopwatch();
        Thread.Sleep(1000);
        st.Restart();
        TestMethod();
        st.Stop();
        Console.WriteLine(st.Elapsed.ToString());
        Console.Read();
    }
}

Now replace {i} to {i.ToString()}, recompile and run.
For {i} the execution time is about 4.11 sec
For {i.ToString()} the execution time is about 2.6 sec

Why? I checked MSIL code and got this

{i} was changed to this

and {i.ToString()} is just .ToString call and string.Format(string, string) proceed

i checked what happening in NET 5 and got this:

It's boxing now, I checked the performance and and it was ~6 sec.

Why it's happening? Why {i.ToString()} is way better in performance vs {i}?
Thank you.

[Clockwork-Muse]

Why {i.ToString()} is way better in performance vs {i}?

The way this code is written, there could be a number of external factors influencing any alleged performance numbers. We use BenchmarkDotNet to mitigate these sorts of factors.
Please re-write your code using the library and update this issue as appropriate.

[zxcvqwerasdf]

namespace Benchmark
{
    public class StringInterpolationBench
    {
        [Benchmark]
        public void StringInterpolationWithoutToString()
        {
            for (int i = 0; i < 100000000; i++)
            {
                string tempTest = $"It's test: {i}";
            }
        }

        [Benchmark]
        public void StringInterpolationWithToString()
        {
            for (int i = 0; i < 100000000; i++)
            {
                string tempTest = $"It's test: {i.ToString()}";
            }
        }

    }
}

[gfoidl]

See String Interpolation in C# 10 and .NET 6 for an in-depth write-out about that topic.

Also note that i.ToString creates a string (so an allocation), that is avoided with the plain string interpolation.