Y a-t-il une différence entre myNullableLong.HasValue et myNullableLong! = Null?

Question

Quand j'ai un long nullable, par exemple, y a-t-il une différence entre

 myNullableLong.HasValue 
 

et

 myNullableLong != null
 

... ou s'agit-il simplement de "sucre syntaxique"?

Answer 1

C'est juste du sucre syntaxique. Ils se comporteront exactement de la même manière - le test de nullité est en fait compilé dans un appel à HasValue toute façon.

Échantillon:

 public class Test
{
    static void Main()
    {
        int? x = 0;
        bool y = x.HasValue;
        bool z = x != null;
    }
}
 

IL:

 .method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       25 (0x19)
  .maxstack  2
  .locals init (valuetype [mscorlib]System.Nullable`1<int32> V_0)
  IL_0000:  ldloca.s   V_0
  IL_0002:  ldc.i4.0
  IL_0003:  call       instance void valuetype [mscorlib]System.Nullable`1<int32>::.ctor(!0)
  IL_0008:  ldloca.s   V_0
  IL_000a:  call       instance bool valuetype [mscorlib]System.Nullable`1<int32>::get_HasValue()
  IL_000f:  pop
  IL_0010:  ldloca.s   V_0
  IL_0012:  call       instance bool valuetype [mscorlib]System.Nullable`1<int32>::get_HasValue()
  IL_0017:  pop
  IL_0018:  ret
} // end of method Test::Main
 

Answer 2

C'est du sucre syntaxique; Nullable<T> est en fait un struct, de sorte qu'il ne peut pas réellement être null; le compilateur transforme les appels de comparer null (comme votre deuxième exemple) dans les appels d' HasValue.

Notez, cependant, que la boxe un Nullable<T> en object entraînera soit la valeur de T (si elle a une valeur) ou null (si ce n'est pas le cas).

I. E.

int? foo = 10; // Nullable<int> with a value of 10 and HasValue = true
int? bar = null; // Nullable<int> with a value of 0 and HasValue = false

object fooObj = foo; // boxes the int 10
object barObj = bar; // boxes null

Console.WriteLine(fooObj.GetType()) // System.Int32
Console.WriteLine(barObj.GetType()) // NullReferenceException

Answer 3

Non.

Le compilateur C # a un support intégré pour Nullable<T> et transformera les opérations d'égalité impliquant null en appels aux membres de la structure.

n == null et n.HasValue seront tous deux compilés en IL identique.