Initialisation des variables nulles .NET

Pour un int.net, il n'est effectivement pas possible d'attribuer null comme c'est un type de valeur, plutôt que d'un type de référence, à moins que vous créer un int? (Nullable<int>), qui, bien que c'est un type de valeur, a spécial de la sémantique et peut donc avoir null lui est assigné.

Dans votre exemple, il n'y a pas de point d'attribution de 0 à var2 comme valeur par défaut pour un type int est zéro. Cela dit, je serais très surpris si le compilateur c# (bien que cela puisse être le cas de tha le compilateur produit différents MSIL pour les deux) /CLR interprète traite à la fois comme étant exactement le même.

private void MyFunction()
{
    int i;
    string s;

    if (s == "3")
    {
        if (i == 1)
        {
        }
    }
}

Garder à l'esprit que dans le présent, en fin de compte inutile, la fonction, vous obtiendrez une erreur de compilation pour la tentative de comparer s et i que les deux sont "non assigné les habitants". Ceci est différent de variables membres d'une classe, comme:

public class MyClass
{
    int i;

    public void MyFunction()
    {
        if (i == 1)
        {
        }
    }
}

OriginalL'auteur Rob

Tout non initialisée utilisation d'une variable en C# va générer un message d'avertissement du compilateur (si il existe au moins un chemin de code de la ne pas initialise). Et il ne doit pas être tous les avertissements dans votre code final!

Dans la deuxième déclaration, vous spécifiez une valeur par défaut. Dans la première déclaration que vous avez supposé que tous les code-chemins affecter une valeur à elle.

OriginalL'auteur ankitjaininfo

Vous ne pouvez pas affecter null à un type de valeur tels que int. Cependant, dans les versions ultérieures de .NET, vous pouvez utiliser nullable types de valeur:

int? var1 = null;

Ce n'est pas une mauvaise pratique pour initialiser des variables dans leurs déclarations. En fait, c'est tout le contraire. Ce faisant, il ne fait aucun doute dans l'esprit de quiconque au sujet de la valeur de la variable après il déclaré.

Aussi, il y a un minimum de performances pour l'affectation de la valeur null à une variable que vous n'avez pas besoin de s'inquiéter à ce sujet. L'accent sur la programmation, pour la précision de la fonctionnalité avant tout, une fois que vous avez, puis de l'ajuster pour toute flagrante des problèmes de performances qui peuvent survenir.

OriginalL'auteur

Le CLR rend difficile que toutes les variables locales seront initialisées à leur valeur par défaut lors de l'entrée dans la méthode avant la première instruction est exécutée. Cette promesse est mis en œuvre par le compilateur JIT. Voir, c'est un peu difficile étant donné que le C# nécessite variables soient initialisées explicitement avant qu'ils ne soient utilisés. Mais voici un exemple:

    static void Main(string[] args) {
        int ix;
        int.TryParse("42", out ix);
        Console.WriteLine("", ix);
    }

Utiliser Debug + Windows + Démontage pour voir le code généré:

//Stack frame setup elided...
00000006  xor         eax,eax                        ; eax = 0
00000008  mov         dword ptr [ebp-0Ch],eax        ; ix = 0
//etc..

Réécrire cette initialiser ix à zéro ce code:

00000006  xor         eax,eax                        ; eax = 0
00000008  mov         dword ptr [ebp-0Ch],eax        ; ix = 0
0000000b  xor         edx,edx                        ; edx = 0
0000000d  mov         dword ptr [ebp-0Ch],edx        ; ix = 0

Eh bien, c'est un peu triste. Le compilateur JIT est généralement assez bon à l'optimisation de code inutile de suite, mais les tentatives maladroites dans ce cas particulier.

Donc, vous êtes un ami qui est juste. Au moins pour le compilateur JIT x86, pas à proximité d'une machine x64 droit maintenant. La surcharge est probablement près de la moitié d'une nanoseconde. Pas quelque chose qui est facile à mesurer.

OriginalL'auteur Hans Passant