Czy użycie" new " na strukturze przydziela ją na stercie lub stosie?

Zobaczmy, czy mogę to wyjaśnić.

Po pierwsze, Ash ma rację: pytanie brzmi a nie o to, gdzie przydzielane są zmienne typu value . To jest inne pytanie - i takie, na które odpowiedź nie jest tylko "na stosie". To jest bardziej skomplikowane niż to (i jeszcze bardziej skomplikowane przez C # 2). Mam artykuł na ten temat i na życzenie go rozbuduję, ale zajmijmy się tylko operatorem new.

Po drugie, wszystkie to naprawdę zależy od tego, o jakim poziomie mówisz. Patrzę na to, co kompilator robi z kodem źródłowym, w kategoriach IL, które tworzy. Jest bardziej niż możliwe, że kompilator JIT zrobi sprytne rzeczy w zakresie optymalizacji dala dość dużo" logicznego " alokacji.

Po Trzecie, ignoruję leki generyczne, głównie dlatego, że właściwie nie znam odpowiedzi, a częściowo dlatego, że to zbytnio skomplikowałoby sprawę.

Wreszcie, wszystko to jest tylko z prądem wdrożenie. C# spec nie precyzuje tego zbyt wiele - jest to efektywny szczegół implementacji. Są tacy, którzy uważają, że deweloperzy zarządzanego kodu naprawdę nie powinni się tym przejmować. Nie jestem pewien, czy posunąłbym się tak daleko, ale warto wyobrazić sobie świat, w którym w rzeczywistości wszystkie zmienne lokalne żyją na stercie - która nadal byłaby zgodna ze specyfikacją.

Istnieją dwie różne sytuacje z operatorem new na typach wartości: możesz wywołać konstruktor bez parametru (np. new Guid()) lub konstruktor parametryczny (np. new Guid(someString)). Generują one znacznie różne IL. Aby zrozumieć dlaczego, musisz porównać specyfikacje C# i CLI: zgodnie z C#, Wszystkie typy wartości mają konstruktor bez parametru. Zgodnie ze specyfikacją CLI, żadne typy wartości nie mają konstruktorów bez parametru. (Pobierz konstruktory typu value z refleksją - nie znajdziesz bez parametru.)

Sensowne jest, aby C# traktował "initialize a value with zeroes" jako konstruktor, ponieważ utrzymuje spójny język - możesz myśleć o new(...) jako zawsze wywołując konstruktor. To ma sens dla CLI myśleć o tym inaczej, ponieważ nie ma prawdziwego kodu do wywołania - a na pewno nie ma kodu specyficznego dla typu.

Robi również różnicę, co zamierzasz zrobić z wartością po jej zainicjowaniu. IL używane dla

Guid localVariable = new Guid(someString);

Różni się od IL używanego do:

myInstanceOrStaticVariable = new Guid(someString);

Dodatkowo, jeśli wartość jest używana jako wartość pośrednia, np. argument do wywołania metody, znów jest trochę inaczej. Aby pokazać wszystkie te różnice, oto krótki program testowy. Nie pokazuje różnicy między zmiennymi statycznymi a zmiennymi instancji: IL różniłby się między stfld i stsfld, ale to wszystko.

using System;

public class Test
{
    static Guid field;

    static void Main() {}
    static void MethodTakingGuid(Guid guid) {}


    static void ParameterisedCtorAssignToField()
    {
        field = new Guid("");
    }

    static void ParameterisedCtorAssignToLocal()
    {
        Guid local = new Guid("");
        // Force the value to be used
        local.ToString();
    }

    static void ParameterisedCtorCallMethod()
    {
        MethodTakingGuid(new Guid(""));
    }

    static void ParameterlessCtorAssignToField()
    {
        field = new Guid();
    }

    static void ParameterlessCtorAssignToLocal()
    {
        Guid local = new Guid();
        // Force the value to be used
        local.ToString();
    }

    static void ParameterlessCtorCallMethod()
    {
        MethodTakingGuid(new Guid());
    }
}

Oto IL dla klasy, z wyłączeniem nieistotnych bitów (takich jak nops):

.class public auto ansi beforefieldinit Test extends [mscorlib]System.Object    
{
    // Removed Test's constructor, Main, and MethodTakingGuid.

    .method private hidebysig static void ParameterisedCtorAssignToField() cil managed
    {
        .maxstack 8
        L_0001: ldstr ""
        L_0006: newobj instance void [mscorlib]System.Guid::.ctor(string)
        L_000b: stsfld valuetype [mscorlib]System.Guid Test::field
        L_0010: ret     
    }

    .method private hidebysig static void ParameterisedCtorAssignToLocal() cil managed
    {
        .maxstack 2
        .locals init ([0] valuetype [mscorlib]System.Guid guid)    
        L_0001: ldloca.s guid    
        L_0003: ldstr ""    
        L_0008: call instance void [mscorlib]System.Guid::.ctor(string)    
        // Removed ToString() call
        L_001c: ret
    }

    .method private hidebysig static void ParameterisedCtorCallMethod() cil  managed    
    {   
        .maxstack 8
        L_0001: ldstr ""
        L_0006: newobj instance void [mscorlib]System.Guid::.ctor(string)
        L_000b: call void Test::MethodTakingGuid(valuetype [mscorlib]System.Guid)
        L_0011: ret     
    }

    .method private hidebysig static void ParameterlessCtorAssignToField() cil managed
    {
        .maxstack 8
        L_0001: ldsflda valuetype [mscorlib]System.Guid Test::field
        L_0006: initobj [mscorlib]System.Guid
        L_000c: ret 
    }

    .method private hidebysig static void ParameterlessCtorAssignToLocal() cil managed
    {
        .maxstack 1
        .locals init ([0] valuetype [mscorlib]System.Guid guid)
        L_0001: ldloca.s guid
        L_0003: initobj [mscorlib]System.Guid
        // Removed ToString() call
        L_0017: ret 
    }

    .method private hidebysig static void ParameterlessCtorCallMethod() cil managed
    {
        .maxstack 1
        .locals init ([0] valuetype [mscorlib]System.Guid guid)    
        L_0001: ldloca.s guid
        L_0003: initobj [mscorlib]System.Guid
        L_0009: ldloc.0 
        L_000a: call void Test::MethodTakingGuid(valuetype [mscorlib]System.Guid)
        L_0010: ret 
    }

    .field private static valuetype [mscorlib]System.Guid field
}

Jak widać, istnieje wiele różnych instrukcji używanych do wywołania konstruktor:

• newobj: przydziela wartość na stosie, wywołuje parametryzowany konstruktor. Używany dla wartości pośrednich, np. do przypisania do pola lub jako argument metody.
• call instance: używa już przydzielonej lokalizacji pamięci masowej(czy to na stosie, czy nie). Jest to użyte w powyższym kodzie do przypisania zmiennej lokalnej. Jeśli tej samej zmiennej lokalnej zostanie przypisana wartość kilka razy za pomocą kilku wywołań new, to po prostu inicjalizuje dane na górze Stara wartość-to nie przydziela więcej miejsca na stosie za każdym razem.
• initobj: używa już przydzielonej lokalizacji pamięci masowej i po prostu usuwa dane. Jest to używane dla wszystkich naszych bez parametru wywołań konstruktora, łącznie z tymi, które przypisują do zmiennej lokalnej. W wywołaniu metody efektywnie wprowadzana jest zmienna lokalna, a jej wartość wymazywana jest przez initobj.

Mam nadzieję, że to pokazuje, jak skomplikowany jest temat, jednocześnie świecąc na niego trochę światła. W niektórych pojęciowych zmysłach, każde wywołanie new przydziela przestrzeń na stosie - ale jak widzieliśmy, tak naprawdę nie dzieje się to nawet na poziomie IL. Chciałbym podkreślić jeden szczególny przypadek. Weź tę metodę:

void HowManyStackAllocations()
{
    Guid guid = new Guid();
    // [...] Use guid
    guid = new Guid(someBytes);
    // [...] Use guid
    guid = new Guid(someString);
    // [...] Use guid
}

To "logicznie" ma 4 alokacje stosu - jeden dla zmiennej i jeden dla każdego z trzech wywołań new - ale w rzeczywistości (dla tego konkretnego kodu) stos jest przydzielany tylko raz, a następnie ta sama lokalizacja pamięci jest ponownie używana.

EDIT: po prostu być jasne, jest to prawdą tylko w niektórych przypadkach... w szczególności, wartość guid nie będzie widoczna, jeśli konstruktor Guid wyrzuci wyjątek, dlatego kompilator C# może ponownie użyć tego samego miejsca stosu. Zobacz post na blogu Erica Lipperta na temat budowy typu wartości , aby uzyskać więcej szczegółów i przypadek, w którym nie ma zastosowania.

Wiele się nauczyłem pisząc tę odpowiedź - proszę o wyjaśnienie, jeśli któraś z nich jest niejasna!