Nullable <int> vs. int? - ¿Hay alguna diferencia?

Question

Aparentemente Nullable<int> y int? son equivalentes en valor. ¿Hay alguna razón para elegir una sobre la otra?

Nullable<int> a = null; 
int? b = null; 
a == b; // this is true 

Answer 1

Ninguna diferencia.

int? es sólo una abreviatura de Nullable<int>, que en sí es la abreviatura de Nullable<Int32>.

El código compilado será exactamente el mismo que elija usar.

Answer 2

El formulario ? es solo una abreviatura del tipo completo. La preferencia personal es la única razón para elegir una sobre la otra.

Detalles completos here.

La sintaxis T? es la abreviatura de Nullable<T>, donde T es un tipo de valor. Las dos formas son intercambiables.

Answer 3

Hay al parecer una diferencia entre los dos cuando se utiliza código primero Entity Framework (EF) generación:

Cuando su entidad contiene una propiedad declarada como:

public class MyEntity 
{ 
    public Nullable<int> MyNullableInt { get; set; } 
} 

EF no generará una propiedad que admite nulos y tendrá que forzar al generador para que admita nulos de esta manera:

public class YourContext : DbContext 
{ 
    public DbSet<MyEntity> MyEntities{ get; set; } 

    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 
     base.OnModelCreating(modelBuilder); 
     modelBuilder.Entity<MyEntity>().Property(x => x.MyNullableInt).IsOptional(); 
    } 
} 

Encendido Por otro lado, si se declara su entidad como:

public class MyEntity 
{ 
    public int? MyNullableInt { get; set; } 
} 

el generador EF propiedad de generar una propiedad anulable con un campo anulable en la tabla de base de datos correspondiente.

Answer 4

Aunque estoy completamente de acuerdo en que en la mayoría de los casos son los mismos, hace poco me encontré con una situación, cuando es una diferencia entre esos dos. Para los detalles morbosos ver this question, pero para darle un ejemplo rápido aquí:

void Test<T>(T a, bool b) 
{ 
    var test = a is int? & b;    // does not compile 
    var test2 = a is Nullable<int> & b; // does compile 
} 

La primera línea da los siguientes mensajes de error:

error CS1003: Syntax error, ':' expected 
error CS1525: Invalid expression term ';' 

Si eres curioso acerca de la razón exacta de este , Realmente le recomiendo que compruebe el ya linked question, pero el problema básico es que en la fase de análisis después de un operador is (o un as), cuando nos enfrentamos a un token ? comprobamos si el siguiente token puede interpretarse como unario operador (& podría ser uno) y si es así: el analizador no se preocupa por la posibilidad de que el token ? sea un modificador de tipo, simplemente usa el tipo anterior y analizará el resto como si el token ? fuera un operador ternario (por lo tanto, el análisis fallará).

Por lo tanto, aunque en general int? y Nullable<int> son intercambiables, hay algunos casos de esquina cuando producen resultados completamente diferentes, debido a la forma en que el analizador ve su código.

Answer 5

Nullable es un tipo genérico, pero int? no es.

Hay algunos escenarios en los que anulable se debe utilizar más de int?

por ejemplo: aquí no puede reemplazar Nullable con int?

¿cómo se puede cambiar el siguiente código sin usar Nullable?

class LazyValue<T> where T : struct 
{ 
    private Nullable<T> val; 
    private Func<T> getValue; 

    // Constructor. 
    public LazyValue(Func<T> func) 
    { 
     val = null; 
     getValue = func; 
    } 

    public T Value 
    { 
     get 
     { 
     if (val == null) 
      // Execute the delegate. 
      val = getValue(); 
     return (T)val; 
     } 
    } 
}