C # Nullable <int> vs int ?: Y a-t-il une différence?

Question

Apparemment, Nullable<int> et int? sont équivalents en valeur. Y a-t-il des raisons de choisir l'un par rapport à l'autre?

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

Answer 1

Aucune différence.

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

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

Answer 2

Alors que je suis complètement d'accord que dans la plupart des cas, ils sont les mêmes, je suis récemment tombé sur une situation, quand il y est une différence entre les deux. Pour les détails techniques voir à cette question, mais pour vous donner un petit exemple 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 pour cela, je vous recommande vraiment de vous afin de vérifier la déjà lié question, mais le problème de base est que, dans l'analyse de la phase après une is (ou as) de l'opérateur, lorsque nous sommes confrontés à un ? jeton, nous vérifions si le prochain jeton peut être interprété comme un opérateur unaire (& pourrait être l'un) et si oui: l'analyseur ne s'inquiète pas de la possibilité de l' ? jeton d'être un modificateur de type, il utilise simplement le type devant elle, et va analyser le reste, comme si l' ? jeton étaient un opérateur ternaire (donc l'analyse échoue).

Donc, en général, int? et Nullable<int> sont interchangeables, il y a quelques cas particuliers lorsqu'ils produisent des résultats complètement différents, en raison de la façon dont l'analyseur voit votre code.

Answer 3

La forme ? n'est qu'un raccourci pour le type complet. La préférence personnelle est la seule raison de choisir l’un sur l’autre.

Détails complets ici .

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

Answer 4

Il y a apparemment une différence entre les deux lors de l'utilisation de code-première EF génération:

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

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

EF ne génèrent pas de nullable de la propriété et vous devrez forcer le générateur pour faire prendre la valeur null comme suit:

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

l'EF générateur de la propriété de générer une nullable bien avec les valeurs null dans le champ correspondant de la table de base de données.