Pregunta Nullable vs. int? - ¿Hay alguna diferencia?


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

76
2017-10-26 23:14


origen


Respuestas:


Ninguna diferencia.

int? es solo una abreviatura de Nullable<int>, que en sí mismo es una abreviatura de Nullable<Int32>.

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


113
2017-10-26 23:16



los ? la forma es solo una abreviatura para el tipo completo. La preferencia personal es la única razón para elegir una sobre la otra.

Todos los detalles aquí.

La sintaxis T? es una abreviatura de    Nullable<T>, dónde T es un tipo de valor   Las dos formas son intercambiables.


20
2017-10-26 23:17



Aunque estoy totalmente de acuerdo en que en la mayoría de los casos son iguales, hace poco encontré una situación, cuando es una diferencia entre esos dos. Para los detalles sangrientos, vea esta pregunta, pero para darle un rápido ejemplo 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 muestra los siguientes mensajes de error:

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

Si tiene curiosidad acerca de la razón exacta de esto, realmente le recomiendo que revise el pregunta vinculada, pero el problema básico es que en la fase de análisis después de is (o un as) operador, cuando enfrentamos un ? token comprobamos si el siguiente simbólico poder ser interpretado como unario operador (& podría ser uno) y si es así: el analizador no se preocupa por la posibilidad de que el ? token es un modificador de tipo, simplemente usa el tipo anterior, y analizará el resto como si el ? token era un operador ternario (por lo tanto, el análisis fallará).

Entonces, 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.


15
2017-07-14 14:03



Aparentemente hay una diferencia entre los dos al usar la generación de Entity Framework (EF) con el código primero.

Cuando su entidad contiene una propiedad declarada como:

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

EF no generará una propiedad que se pueda anular y tendrás que forzar al generador para que se pueda anular 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();
    }
}

Por otro lado, si declaras tu entidad como:

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

el generador de EF generará una propiedad que puede ser anulada con un campo que puede ser anulado en la tabla correspondiente de la base de datos.


4
2018-06-05 14:06



Nullable es un tipo genérico, pero ¿En t? no es.

Hay algunos escenarios donde Nullable debe usarse sobre ¿En t?

por ejemplo: aquí no puedes reemplazar Nullable con ¿En t? 

¿Cómo puedes cambiar el código a continuación 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;
      }
   }
}

1
2017-07-30 23:32