L'utilisation de " new " sur une structure l'alloue-t-elle sur le tas ou la pile?

OK, voyons si je peux rendre ça plus clair.

Tout d'abord, Ash a raison: la question Est Pas sur l'endroit où le type de valeur variables sont alloués. C'est une question différente - et à laquelle la réponse n'est pas seulement "sur la pile". C'est plus compliqué que cela (et rendu encore plus compliqué par C# 2). J'ai un article sur le sujet et je vais le développer si demandé, mais traitons juste de l'opérateur new.

Deuxièmement, tous les cela dépend vraiment de quel niveau vous parlez. Je regarde ce que le compilateur fait avec le code source, en termes D'IL qu'il crée. Il est plus que possible que le compilateur JIT fasse des choses intelligentes en termes d'optimisation de beaucoup d'allocation "logique".

Troisièmement, j'ignore les génériques, surtout parce que je ne connais pas vraiment la réponse, et en partie parce que cela compliquerait trop les choses.

Enfin, tout cela est juste avec le courant application. La spécification C# ne spécifie pas beaucoup de cela-c'est effectivement un détail d'implémentation. Il y a ceux qui croient que les développeurs de code géré ne devraient vraiment pas se soucier. Je ne suis pas sûr d'aller aussi loin, mais il vaut la peine d'imaginer un monde où en fait toutes les variables locales vivent sur le tas - ce qui serait toujours conforme à la spécification.

Il existe deux situations différentes avec l'opérateur new sur les types de valeurs: vous pouvez appeler un constructeur sans paramètre (par exemple new Guid()) ou un constructeur paramétrable (par exemple new Guid(someString)). Ceux-ci génèrent des IL significativement différents. Pour comprendre pourquoi, vous devez comparer les spécifications C# et CLI: selon C#, Tous les types de valeurs ont un constructeur sans paramètre. Selon la spécification CLI, Aucun Type de valeur n'a de constructeurs sans paramètre. (Récupérez les constructeurs d'un type de valeur avec réflexion un certain temps - vous n'en trouverez pas un sans paramètre.)

Il est logique que C# traite "initialiser une valeur avec des zéros" comme un constructeur, car il maintient le langage cohérent - vous pouvez penser à new(...) comme toujours appelant un constructeur. Il est logique pour la CLI de penser différemment, car il n'y a pas de code réel à appeler - et certainement pas de code spécifique au type.

Cela fait également une différence entre ce que vous allez faire avec la valeur après l'avoir initialisée. L'IL utilisé pour

Guid localVariable = new Guid(someString);

Est différent de L'IL utilisé pour:

myInstanceOrStaticVariable = new Guid(someString);

En outre, si la valeur est utilisée comme valeur intermédiaire, par exemple un argument à un appel de méthode, les choses sont légèrement différentes à nouveau. Pour montrer toutes ces différences, voici un programme de test court. Il ne montre pas la différence entre les variables statiques et les variables d'instance: L'IL différerait entre stfld et stsfld, mais c'est tout.

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());
    }
}

Voici L'IL pour la classe, à l'exclusion des bits non pertinents (tels que 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
}

Comme vous pouvez le voir, il y a beaucoup d'instructions différentes utilisées pour appeler le constructeur:

• newobj: alloue la valeur sur la pile, appelle un constructeur paramétré. Utilisé pour les valeurs intermédiaires, par exemple pour l'affectation à un champ ou l'utilisation comme argument de méthode.
• call instance: utilise un emplacement de stockage déjà alloué (que ce soit sur la pile ou non). Il est utilisé dans le code ci-dessus pour l'affectation à une variable locale. Si la même variable locale se voit attribuer une valeur plusieurs fois à l'aide de plusieurs appels new, elle initialise simplement les données au - dessus du ancienne valeur - elle n'alloue pas plus d'espace de pile à chaque fois.
• initobj: utilise un emplacement de stockage déjà alloué et efface simplement les données. Ceci est utilisé pour tous nos appels de constructeur sans paramètre, y compris ceux qui affectent à une variable locale. Pour l'appel de méthode, une variable locale intermédiaire est effectivement introduite, et sa valeur est effacée par initobj.

J'espère que cela montre à quel point le sujet est compliqué, tout en y mettant un peu de lumière en même temps. Dans certains sens conceptuels , chaque appel à new alloue de l'espace sur la pile - mais comme nous l'avons vu, ce n'est pas ce qui se passe vraiment, même au niveau IL. J'aimerais attirer votre attention sur un cas particulier. Prenez cette méthode:

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

Cela" logiquement " a 4 allocations de pile - une pour la variable, et une pour chacun des trois appels new - mais en fait (pour ce code spécifique) la pile n'est allouée qu'une seule fois, puis le même emplacement de stockage est réutilisé.

EDIT: juste pour être clair, cela n'est vrai que dans certains cas... en particulier, la valeur de guid ne sera pas visible si le constructeur Guid lève une exception, c'est pourquoi le compilateur C# est capable de réutiliser le même emplacement de pile. Voir le blog D'Eric Lippert sur la construction de type de valeur pour plus de détails et un cas où ne s'applique pas à.

J'ai beaucoup appris en écrivant cette réponse - veuillez demander des éclaircissements si cela n'est pas clair!