¿Hay alguna diferencia entre myNullableLong.HasValue y myNullableLong! = Null?

Question

Cuando tengo una larga anulable, por ejemplo, ¿hay alguna diferencia entre

myNullableLong.HasValue 

y

myNullableLong != null 

... o es sólo 'azúcar sintáctico'?

Answer 1

Es azúcar sintáctico. Se comportarán exactamente de la misma manera; la prueba de nulidad en realidad se compila en una llamada al HasValue de todos modos.

muestra:

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

Es azúcar sintáctico; Nullable<T> es en realidad un struct, por lo que no puede en realidad ser null; el compilador convierte las llamadas que se comparan con null (como su segundo ejemplo) en llamadas al HasValue.

Tenga en cuenta, sin embargo, que el boxeo un Nullable<T> en un object resultará ya sea en el valor de T (si tiene un valor) o null (si no lo hace).

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

Nº

El compilador de C# se ha incorporado en el apoyo a Nullable<T> y a su vez, las operaciones que implican la igualdad null en llamadas a los miembros de la estructura.

n != null y n.HasValue compilarán ambos para idéntico IL.