? Opérateur (nullable) en C #

Ce qui est changé en appliquant un opérateur nullable sur un type de données de type valeur qui peut désormais stocker null.

Comme d’autres l’ont dit, “?” est juste un raccourci pour le changer en Nullable . Ceci est juste un autre type de valeur avec un indicateur booléen pour indiquer s’il existe réellement une valeur utile ou s’il s’agit de la valeur null pour le type. En d’autres termes, Nullable ressemble un peu à ceci:

 public struct Nullable { private readonly bool hasValue; public bool HasValue { get { return hasValue; } } private readonly T value; public T value { get { if (!hasValue) { throw new InvalidOperationException(); } return value; } } public Nullable(T value) { this.value = value; this.hasValue = true; } // Calling new Nullable() or whatever will use the // implicit initialization which leaves value as default(T) // and hasValue as false. } 

Évidemment, dans le code réel, il y a plus de méthodes (comme GetValueOrDefault() ) et d’opérateurs de conversion, etc. Le compilateur C # ajoute des opérateurs levés qui remplacent effectivement les opérateurs d’origine de T

Au risque de ressembler à un disque brisé, il s’agit toujours d’un type de valeur. Cela ne concerne pas la boxe … et quand vous écrivez:

 int? x = null; 

ce n’est pas une référence nulle – c’est la valeur nulle de Nullable , c’est-à-dire celle où hasValue est false .

Lorsqu’un type nullable est mis en boîte, le CLR a une fonctionnalité grâce à laquelle la valeur est mise en boîte avec une référence null ou un T. en boîte simple. Donc, si vous avez un code comme celui-ci:

 int? x = 5; int y = 5; object o1 = x; object o2 = y; 

Les valeurs encadrées mentionnées par o1 et o2 sont indiscernables. Vous ne pouvez pas dire que cela est le résultat de la boxe d’un type nullable.

Le ? la syntaxe est le sucre syntaxique de la Nullable .

En substance, quand vous écrivez int? myNullableInt int? myNullableInt , le compilateur le Nullable myNullableInt par Nullable myNullableInt .

De MSDN (faites défiler jusqu’à “Aperçu des types nullables”):

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

Rien n’est modifié sur le type de valeur lui-même, il est simplement System.Nullable dans une System.Nullable . http://msdn.microsoft.com/en-us/library/b3h38hb0.aspx

Le type passe de ce qu’il était auparavant à un type Nullable.

Si vous aviez un int et que vous décidiez de le faire ?:

 int myInt; 

Et vous le faites:

 int? myInt; 

c’est maintenant:

 Nullable myInt; 

En réalité.

En termes de base, un type nullable est une version encadrée du type normal qui contient un champ booléen supplémentaire appelé hasValue. Lorsque ce champ est défini sur false, l’instance est null.

Découvrez cette réponse pour un peu plus de détails sur l’implémentation CLR, et pourquoi ils l’auraient choisie: Types de nullité Boxing / Unboxing – Pourquoi cette implémentation?