Anulável <int> vs. int? - Existe alguma diferença?

Aparentemente Nullable<int>e int?são equivalentes em valor. Existe alguma razão para escolher um em vez do outro?

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

Sem diferença.

int?é apenas uma abreviatura de Nullable<int>, que em si é uma abreviatura de Nullable<Int32>.

O código compilado será exatamente o mesmo que você escolher usar.

O ?formulário é apenas uma abreviação para o tipo completo. A preferência pessoal é a única razão para escolher um em vez do outro.

Detalhes completos aqui .

A sintaxe T?é um atalho para Nullable<T>, onde Té um tipo de valor. As duas formas são intercambiáveis.

Embora concorde plenamente que na maioria dos casos eles são o mesmo, recentemente deparei com uma situação, quando não é a diferença entre os dois. Para os detalhes sangrentos, consulte esta pergunta , mas para dar um exemplo rápido aqui:

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
}

A primeira linha fornece as seguintes mensagens de erro:

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

Se você está curioso sobre o motivo exato para isso, eu realmente recomendo que você verifique a questão já vinculada , mas o problema básico é que na fase de análise após um is(ou um as) operador, quando nos deparamos com um ?token, verificamos se o próximo token pode ser interpretado como um operador unário ( &poderia ser um) e se assim for: o analisador não se preocupa com a possibilidade de o ?token ser um modificador de tipo, ele simplesmente usa o tipo antes dele e irá analisar o resto como se o? token era um operador ternário (portanto, a análise falhará).

Portanto, embora em geral int?e Nullable<int>sejam intercambiáveis, existem alguns casos extremos em que eles produzem resultados completamente diferentes, devido à forma como o analisador vê seu código.

Aparentemente, há uma diferença entre os dois ao usar a geração de Entity Framework (EF) de código primeiro:

Quando sua entidade contém uma propriedade declarada como:

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

EF não irá gerar uma propriedade anulável e você terá que forçar o gerador para torná-la anulável assim:

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 outro lado, se você declarar sua entidade como:

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

o gerador EF irá gerar uma propriedade anulável com um campo anulável na tabela de banco de dados correspondente.

Nullable é um tipo genérico, mas int? não é.

Existem alguns cenários em que Nullable deve ser usado em vez de int?

por exemplo: aqui você não pode substituir Nullable por int?

como você pode alterar o código abaixo sem 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;
      }
   }
}