Pourquoi ne tente-t-il pas d'ajouter à une valeur nulle une exception InvalidOperationException?

Question

int? x = null; 
x = x + 1; // Works, but x remains null 

Je m'attendrais à ce que le compilateur tente de transformer x en int, mais apparemment, il ne le fait pas.

Modifié par 280Z28: Modifié NullReferenceException à InvalidOperationException, ce qui déclenche Nullable<T>.Value lorsque HasValue est faux.

Answer 1

Ceci est conforme à la spécification relative aux opérateurs binaires levés. De §7.2.7:

Pour les opérateurs binaires

+ - */% & |^<< >>

une forme levée d'un opérateur existe si les types d'opérandes et de résultat sont tous les types de valeur non nulle. La forme levée est construite en ajoutant un seul modificateur ? à chaque opérande et type de résultat. L'opérateur levé produit une valeur nulle si l'un des opérandes ou les deux sont NULL (une exception étant les opérateurs & et | du type bool?, Comme décrit au §7.10.3). Sinon, l'opérateur levé déballe les opérandes, applique l'opérateur sous-jacent et encapsule le résultat.

Le raisonnement est le suivant: vous êtes à penser à null pour un type nullable comme signifiant « Je ne sais pas ce que la valeur est. » Quel est le résultat de "Je ne sais pas" plus un? "Je ne sais pas." Ainsi, le résultat devrait être null.

Answer 2

Malheureusement, ce n'est pas le cas. Le X dans x = X + 1 est nul comme dans la première ligne de sorte que vous ajoutez 1 à null, ce qui équivaut à null.

Comme il est un int nullable, vous pouvez utiliser x.HasValue pour vérifier si elle a une valeur, puis x.Value pour obtenir la valeur int réelle sur

Answer 3

Pourquoi vous attendez-vous le compilateur de le jeter comme int quand vous l'avez déclaré comme Nullable? Le compilateur fait ce que vous lui avez dit de faire et null +1 = null.

Vous devrez lancer un cast explicitement ou vérifier x.HasValue avant d'essayer d'ajouter un int.

Answer 4

Les valeurs nulles ne sont jamais réellement des références nulles. Ce sont toujours des références d'objets. Leurs classes internes remplacent les opérateurs == et =. Si elles sont comparées à null, elles renverront la valeur de la propriété HasValue.

Answer 5

La raison est que le compilateur crée un opérateur « levé » pour les types nullables - dans ce cas, il est quelque chose comme:

public static int? operator +(int? a, int? b) 
{ 
    return (a == null || b == null) ? (int?)null : a.Value + b.Value 
} 

Je pense que si vous essayez d'affecter le résultat à un non Valeur nullable, le compilateur sera forcé d'utiliser la surcharge non nullable et convertir x en un int.

e.g. int i = x + 1; //throws runtime exception 

Answer 6

Indépendamment de savoir si x est réellement jamais nul, ce n'est même pas le point.

Le point est, quand avez-vous déjà vu un NullReferenceException en essayant d'effectuer un ajout?

L'exemple suivant ne lance pas non plus un NullReferenceException et est parfaitement valide.

string hello = null; 
string world = "world"; 
string hw = hello+world; 

Vous n'obtenir un NullReferenceException si vous essayez d'accéder à un membre sur un objet qui est nul.

Answer 7

int? ne peut jamais être nul parce que c'est une structure. Les structs vivent sur la pile et la pile ne gère pas bien le null.

Voir What is a NullPointerException, and how do I fix it?

En outre, les types nullables ont 2 propriétés très utiles: HasValue, valeur

Ce code:

 if (x != null) 
     { 
      return (int) x; 
     } 

Faut-être remaniée à ceci:

 if (x.HasValue) 
     { 
      return x.Value; 
     }