Nullable types

NULL literalmente significa "nada", una variable que no contiene ningún valor todavía. En este punto del tutorial ya debes haber lidiado con variables que no estaban inicializadas, fuera a propósito o no; si es así ya sabes que siempre tienes que asegurarte que una variables tiene un valor antes de intentar acceder a ella, si no te encontrarás con una NullReferenceException.

NULLs son especialmente relevantes cuando trabajas con tus propios objetos y con strings. Por otro lado, cuando trabajas con números (por ejemplo un "integer"), verás que siempre tienen un valor (por defecto). Para un "integer" el valor por defecto es 0 (cero), el cual no debe confundirse con NULL ya que no son iguales, aunque algunos lenguages de programación no tipados puede que los traten igual. 0 es un número y NULL es nada.

Así que si tú, en algún momento, quieres tener un número que represente un valor no definido (NULL), es posible que te sientas extrañado, porque no puedes asignar NULL a una variable entera (int). A menos que ese entero haya sido definido como anulable (una construcción especial creada para situaciones como esta). Para definir una variable como anulable tienes que añadir detrás del tipo un signo de interrogación. Aquí hay un ejemplo para mostrar la diferencia:

int notNullable = null; // Will cause an error from the compiler

int? nullable = null; // Just fine - it's nullable!

Esto es válido para todos los tipos de valorcomo "integers", "floats", "bools" y "structs". Por otra parte, strings y objectos, son tipos por referencia y no pueden ser declarados como anulables porque, por defecto, ya son anulables.

Comprobando null en un objecto anulable

Así que ahora que has definido una variable la cual puede ser nula, verificar si ese es el caso obviamente es importante. Puedes hacer esto de dos maneras: simplemente comparar la variable con la keyword null, como harías con otros tipos, o usar la propiedad HasValue que cualquier objeto nulable hereda de System.Nullable. Aquí tienes un ejemplo:

int? nullable = null;  
if (nullable == null)  
    Console.WriteLine("It's a null!");  
if (!nullable.HasValue)  
    Console.WriteLine("It's a null!");

El resultado es el mismo, así que usa el método que te parezca más fácil de leer y entender. Dado que nuestro valor puede ser nulo, deberías comprobarlo siempre antes de usarlo o de lo contrario puedes encontrarte con una Excepción.

Usando el valor de un nulable

Un objeto anulable hereda la propiedad Value desde System.Nullable. Esta puede ser usada para recuperar el valor actual de el objeto. sin embargo, para simples operaciones de comparación (por ejemplo == o !=) C# te permite omitir la propiedad Value y comparar directamente el objeto anulable. En otras palabras, estos ejemplos tienes el mismo resultado:

int? nullable = 42;

if (nullable.Value == 42)  
    Console.WriteLine("It's 42!");  

if (nullable == 42)  
    Console.WriteLine("It's 42!");

Los objetos anulables siempre provienen de un tipo base, como por ejemplo integer en los ejemplos anteriores. Mientras esos tipos de datos pueden tener un valor por defecto, el valor por defecto de un anulable es siempre null. Este es el motivo por el que tienes que verificar que un obejeto no sea nulo antes de usarlo. Sin embargo un objeto anulable hereda un método que puede usar: GetValueOrDefault(). El método retorno el valor del aobjeto anulable, a menos que sea nulo, en ese caso devuelve el valor por defecto del tipo original. Asi que, para un entero anulable, retornaría 0, para un booleano anulable retornaría falsey así para el resto. Esto te permite manejar tanto la validación como la obtención del valor en la misma sentencia:

if ((nullable.HasValue) && (nullable.Value == 42))
    Console.WriteLine("It's 42!");

if(nullable.GetValueOrDefault() == 42)
    Console.WriteLine("It's 42!");

Como puedes ver, el último ejemplo es más corto y fácil de entender, obteniéndose el mismo resultado

Resumen

Los tipos de valores en C#, tales como integers y booleans, siempre tienen un valor por defecto. Si tú quieres evitar ese comportamiento, por ejemplo porque necesitas diferenciar entre 0 y nulo ,o bien porque necesitas saber si un usuario ha seleccionado "falso" o si la variable simplemente tiene el valor por defecto de false, en estos caso tu puedes hacer que tú variable sea anulable añadiéndole al final del nombre del tipo una ? (interrogación).