Hace un tiempo, de hecho, hace casi dos años hice un post sobre los tipos nullables en C#.
En aquel vídeo expliqué cómo funcionan los tipos nullables utilizando el carácter ? y cómo comprobar si esa variable es null o no, una forma sencilla, siempre y cuando los tipos sean nullables utilizando .HasValue().
Pero qué pasa si no tenemos los tipos de referencia nullable activados en nuestro proyecto qué opciones tenemos para validar si una variable es null o no.
- Nota: obviamente lo que voy a explicar también funciona con los tipos de referencia nullables.
Índice
1 - Para ponernos en contexto
Este post lo realizo principalmente porque en las últimas versiones de C# Hemos visto como la forma de comprobar si un elemento es nulo o no ha cambiado, múltiples veces,por lo que conocer esta información puede ser muy útil si estamos haciendo revisiones de código, o si queremos ampliar nuestro conocimiento en la materia.
2 - Null check en C# 6 y anteriores
Para las versiones de C# 6 (.NET Framework 4.6) la única opción que tenemos es utilizar los operadores de igualdad == para saber si el valores es nulo o != para saber si el valor es diferente de nulo.
int i = null;
if(i == null)
{
return "el valor de I es null, y eso no puede ser";
}
if (i != null)
{
return "el valor No es null";
}
El problema viene cuando descubres que tanto == como != se pueden sobrescribir en el código, por lo tanto, dejarían de tener el efecto que queremos:
public class PlaceholderClass
{
public static bool operator ==(PlaceholderClass lhs, PlaceholderClass rhs)
{
return true;
}
public static bool operator !=(PlaceholderClass lhs, PlaceholderClass rhs)
{
return true;
}
}
//Aqui el código
PlaceholderClass obj = null;
if(obj != null)
{
return "el if siempre devuelve verdadero";
}Como vemos en el ejemplo, el operador de igualdad devuelve siempre verdadero, da igual si el valor real es verdadero o falso, así que podemos causar sin querer funcionamiento no esperado. (aunque es muy raro sobreescribir los operadores).
3 - Null check en C# 7
Para las versiones de C# 7 (.NET Framework 4.7 y > .NET standard 2.0) tenemos una nueva opción disponible la palabra clave is la cual nos deja comprobar si un objeto es nulo o no.
string i = null;
if (i is null)
{
return "El valor es null";
}
Ahí podemos ver, y es fácil de leer cómo comprobar ese objeto.
Sin embargo, tiene una pega, y es la forma de comprobar si un objeto no es nulo.
Para lo que tenemos dos opciones:
A - Utilizar is object si la variable que comprobamos es un objeto, no es nulo, por lo que es lo mismo a comprobar si no es nulo.
B - Negar el is con !(obj is null) el valor entre paréntesis da negativo, luego lo niegas, y se convierte en positivo.
if (i is object)
{
return "El valor no es null";
}
if (!(i is null))
{
return "El valor no es null";
}En mi opinión ninguna de las dos son suficientemente claras, y de hecho, generan confusión.
Eso sin olvidar el null-coalescing operator que también nos permite controlar si un objeto es null o no
Obj result = aquiElObeto ?? new Obj();
4 - Null check en C# 8
Con la llegada de C# 8 (.NET Standard 2.1 y .NET Core 3.1+) nos llegó el “pattern matching” y con una nueva forma de comprobar si un elemento es un objeto o no, con los caracteres {}.
string i = null;
if (i is { })
{
return "this cast to true";
}
5 - Null check en C# 9
en C# 9 (.NET 5) ese problema o “sin sentido” fue arreglado, y ya podemos hacer comprobaciones de null con el código is not null lo cual es fácil claro y sencillo de leer y comprender para todo aquel que tenga el código delante.
string i = null;
if (i is not null)
{
return "El valor no es null";
}Como vemos facil rapido y sencillo, al fin.
6 - Qué nos depará el futuro?
Adicionamente he encontrado una propuesta de Jared Parsons que me parece muy interesante la cual podemos resumir en que es el lenguaje el que controla la validación del null-check, podemos utilizar el parámetro de entrada de un método, para comprobar que ese parámetro no es null con el operador !.
public string Execute(PlaceholderClass test!)
{
//code
}
El programa lanzará una excepción ArgumentNullException si el parámetro es nulo.
Puedes encontrar la propuesta aquí: enlace.
Pero por ahora, esta funcionalidad no está incluida en el lenguaje.
Actualmente si activamos <nullable>enable en nuestro proyecto y utilizamos Rider e indicamos la exclamación nos lo traduce automáticamente al siguiente código:
public string Execute(PlaceholderClass test)
{
if (test == null) throw new ArgumentNullException(nameof(test));
//resto del código
}
Lo que me hace pensar que por lo menos desde Jetbrains se están preparando para incluir dicha funcionalidad.
Conclusión
Hasta aquí el post, hemos visto cómo comprobar si una variable es null o no en las diferentes versiones de .NET
Y en caso de que añadan alguna nueva (que lo harán) en el futuro, iré actualizando este post.
