Type int ? vs type int

Question

J'ai cette comparaison qui équivaut à false comme prévu

bool eq = typeof(int?).Equals(typeof(int));

maintenant j'ai ce code

List<object> items = new List<object>() { (int?)123 };
int result = items.OfType<int>().FirstOrDefault();

mais cela renvoie 123 - de toute façon, cette valeur est de type int?

Comment est-ce possible ?

Answer 1

Les types nuls sont soumis à des règles spéciales de "mise en boîte" ; on parle de "mise en boîte" lorsqu'un type de valeur est traité comme un type de valeur. object selon votre code. Contrairement aux types de valeurs ordinaires, un type de valeur nullable est encadré. soit como null (régulier null sans type), ou comme le non-nulle (le T en T? ). Donc : un int? est encadré comme un int et non un int? . Ensuite, lorsque vous utilisez OfType<int>() sur elle, vous obtenez toutes les valeurs qui sont int qui est : la valeur unique que vous avez passée, puisqu'elle es de type int .

Answer 2

Un type de valeur nullable est encadré par les règles suivantes

• Si HasValue renvoie à false la référence nulle est produite.
• Si HasValue renvoie à true une valeur de la catégorie de valeur sous-jacente T est encadré, pas l'instance de nullable.

---

Dans votre exemple, la deuxième règle a été suivie comme vous l'avez indiqué :

var i = (object)(int?)123;

Answer 3

C'est un peu tard, mais en plus de la réponse de Marc à votre question, je veux donner quelques informations supplémentaires sur les types de valeurs nuls dans CLR.

Le CLR a un support intégré pour les types de valeurs nullables. Ce site soutien particulier est prévu pour boxe, unboxing, appel GetType l'appel des méthodes de l'interface .

Par exemple, vérifions GetType() :

Int32? x = 5;
Console.WriteLine(x.GetType());

Que pensez-vous qu'il va imprimer dans la console ? System.Nullable<Int32 ? Non, le résultat est System.Int32 .

Ou, vérifions la boxe, ce que vous avez noté dans votre question :

Int32? n =5;
Object o = n;
Console.WriteLine("o's type={0}", o.GetType()); // "System.Int32"

La règle est la suivante :

Lorsque le CLR met en boîte une instance Nullable, il vérifie s'il s'agit de est nulle, et si c'est le cas, le CLR ne met rien en boîte, et null est retourné. Si l'instance nullable n'est pas nulle, le CLR prend la valeur valeur de l'instance nullable et la met en boîte. En d'autres termes, un Nullable avec une valeur de 5 est transformé en un boxed-Int32 avec une valeur de 5. valeur de 5.

Et, à la fin, je veux expliquer comment le CLR ajoute un support spécial pour appeler des méthodes d'interface à partir de types nuls. Jetons un coup d'oeil à cela :

Int32? n = 5;
Int32 result = ((IComparable) n).CompareTo(5); // Compiles & runs OK
Console.WriteLine(result); // 0

Dans le code précédent, je lance n, un Nullable<Int32> à IComparable<Int32> une interface type. Cependant, le Nullable<T> ne met pas en œuvre l'option IComparable<Int32> en tant qu'interface Int32 fait. Le compilateur C# permet à ce code de compiler quand même.