Bei der gestrigen Beantwortung einer Frage zu SO ist mir aufgefallen, dass der Compiler eine zusätzliche lokale Variable erstellt, wenn ein Objekt mit einem Objektinitialisierer initialisiert wird.

Betrachten Sie den folgenden C # 3.0-Code, der im Release-Modus in VS2008 kompiliert wurde:

public class Class1
{
    public string Foo { get; set; }
}

public class Class2
{
    public string Foo { get; set; }
}

public class TestHarness
{
    static void Main(string[] args)
    {
        Class1 class1 = new Class1();
        class1.Foo = "fooBar";

        Class2 class2 =
            new Class2
            {
                Foo = "fooBar2"
            };

        Console.WriteLine(class1.Foo);
        Console.WriteLine(class2.Foo);
    }
}

Mit Reflector können wir den Code für die Main-Methode untersuchen:

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 2
    .locals init (
        [0] class ClassLibrary1.Class1 class1,
        [1] class ClassLibrary1.Class2 class2,
        [2] class ClassLibrary1.Class2 <>g__initLocal0)
    L_0000: newobj instance void ClassLibrary1.Class1::.ctor()
    L_0005: stloc.0 
    L_0006: ldloc.0 
    L_0007: ldstr "fooBar"
    L_000c: callvirt instance void ClassLibrary1.Class1::set_Foo(string)
    L_0011: newobj instance void ClassLibrary1.Class2::.ctor()
    L_0016: stloc.2 
    L_0017: ldloc.2 
    L_0018: ldstr "fooBar2"
    L_001d: callvirt instance void ClassLibrary1.Class2::set_Foo(string)
    L_0022: ldloc.2 
    L_0023: stloc.1 
    L_0024: ldloc.0 
    L_0025: callvirt instance string ClassLibrary1.Class1::get_Foo()
    L_002a: call void [mscorlib]System.Console::WriteLine(string)
    L_002f: ldloc.1 
    L_0030: callvirt instance string ClassLibrary1.Class2::get_Foo()
    L_0035: call void [mscorlib]System.Console::WriteLine(string)
    L_003a: ret 
}

Hier sehen wir, dass der Compiler zwei Referenzen auf eine Instanz von generiert hatClass2 (class2 und<>g__initLocal0), aber nur ein Verweis auf eine Instanz vonClass1 (class1).

Jetzt bin ich nicht sehr vertraut mit IL, aber es sieht so aus, als würde es instanziieren<>g__initLocal0vor dem Einstellenclass2 = <>g__initLocal0.

Warum passiert das?

Ergibt sich dann ein Performance-Overhead bei der Verwendung von Objektinitialisierern (auch wenn dieser sehr gering ist)?