¿Por qué el intento de agregar un valor nulo arroja una InvalidOperationException?

Question

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

Esperaría que el compilador intentara lanzar x como un int, pero aparentemente no es así.

Editar por 280Z28: Se ha cambiado NullReferenceException-InvalidOperationException, que es lo que Nullable<T>.Value tiros cuando HasValue es falso.

Answer 1

Esto es según la especificación para los operadores binarios levantados. De §7.2.7:

Para los operadores binarios

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

una forma elevada de un operador existe si los tipos de los operandos y resultados son todos los tipos de valor no anulable. La forma elevada se construye agregando un modificador único ? a cada operando y tipo de resultado. El operador elevado produce un valor nulo si uno o ambos operandos son nulos (una excepción son los operadores & y | del tipo bool ?, como se describe en §7.10.3). De lo contrario, el operador levantado desenvuelve los operandos, aplica el operador subyacente y envuelve el resultado.

El razonamiento es el siguiente: usted es pensar en null para un tipo anulable en el sentido de "No sé cuál es el valor." ¿Cuál es el resultado de "No sé" más uno? "No lo sé." Por lo tanto, el resultado debería ser null.

Answer 2

Desafortunadamente no es así. El X en x = X + 1 es nulo como en la primera línea, por lo que agrega 1 a nulo, lo que equivale a nulo.

Como se trata de un int anulable, puede utilizar x.HasValue para comprobar si tiene un valor, y luego x.Value para obtener el valor real int cabo

Answer 3

¿Por qué se puede esperar del compilador para proyectarlo como int cuando lo has declarado como Nullable? El compilador está haciendo lo que le has indicado y null +1 = null.

Deberás realizar un cobro explícito o marcar x.HasValue antes de intentar agregar un int.

Answer 4

Nullables nunca son realmente referencias nulas. Siempre son referencias de objetos. Sus clases internas anulan los operadores == y =. Si se comparan con nulo, devolverán el valor de la propiedad HasValue.

Answer 5

La razón de esto es que el compilador crea un operador 'levantado' para los tipos anulables - en este caso, es algo así como:

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

Creo que si se intenta asignar el resultado a un no valor nulo, el compilador se verá obligado a utilizar la sobrecarga no nulable y convertir x a un int.

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

Answer 6

Independientemente de si x en realidad nunca es nulo, ni siquiera es el punto.

El punto es, ¿cuándo ha visto alguna vez un NullReferenceException al intentar realizar una adición?

El siguiente ejemplo tampoco arroja un NullReferenceException y es perfectamente válido.

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

Sólo se conseguiría un NullReferenceException si se intenta acceder a un miembro de un objeto que es nulo.

Answer 7

int? nunca puede ser nulo porque es una estructura. Las estructuras viven en la pila y la pila no maneja bien nula.

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

Además, los tipos anulables tienen 2 propiedades muy útiles: HasValue, Valor

este código:

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

caso de que se refactorizado a esto:

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