Nullable <int> contre int? - Y a-t-il une différence?

Apparemment Nullable<int>et int?sont équivalents en valeur. Y a-t-il des raisons de choisir l'un plutôt que l'autre?

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

Aucune différence.

int?est juste un raccourci pour Nullable<int>, qui lui-même est un raccourci pour Nullable<Int32>.

Le code compilé sera exactement le même quel que soit celui que vous choisissez d'utiliser.

Le ?formulaire n'est qu'un raccourci pour le type complet. La préférence personnelle est la seule raison de choisir l'un plutôt que l'autre.

Détails complets ici .

La syntaxe T?est un raccourci pour Nullable<T>, où Test un type valeur. Les deux formes sont interchangeables.

Bien que je sois tout à fait d'accord pour dire que dans la plupart des cas, ils sont identiques, je suis récemment tombé sur une situation où il y a une différence entre les deux. Pour les détails sanglants, voyez cette question , mais pour vous donner un exemple rapide ici:

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 première ligne donne les messages d'erreur suivants:

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

Si vous êtes curieux de connaître la raison exacte de cela, je vous recommande vraiment de vérifier la question déjà liée , mais le problème de base est que dans la phase d'analyse après un is(ou un as) opérateur, lorsque nous sommes confrontés à un ?jeton, nous vérifions si le suivant le jeton peut être interprété comme un opérateur unaire ( &pourrait en être un) et si c'est le cas: l'analyseur ne se soucie pas de la possibilité que le ?jeton soit un modificateur de type, il utilise simplement le type avant lui et analysera le reste comme si le ?token était un opérateur ternaire (ainsi l'analyse échouera).

Ainsi, bien qu'en général int?et qu'ils Nullable<int>soient interchangeables, il y a des cas secondaires où ils produisent des résultats complètement différents, en raison de la façon dont l'analyseur voit votre code.

Il y a apparemment une différence entre les deux lors de l'utilisation de la génération Entity Framework (EF) avec code first:

Lorsque votre entité contient une propriété déclarée comme:

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

EF ne générera pas de propriété nullable et vous devrez forcer le générateur à le rendre nullable comme ceci:

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();
    }
}

D'autre part, si vous déclarez votre entité comme:

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

le générateur EF générera une propriété Nullable avec un champ Nullable dans la table de base de données correspondante.

Nullable est un type générique, mais int? n'est pas.

Il existe certains scénarios où Nullable doit être utilisé sur int?

par exemple: ici vous ne pouvez pas remplacer Nullable par int?

comment pouvez-vous changer le code ci-dessous sans utiliser 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;
      }
   }
}