Comprobación de parámetros nulos en C# 10 y .NET 6 en 10 minutos o menos

Preparando el escenario - Comprobación de parámetros nulos

Tim comienza creando una sencilla aplicación de consola .NET 6 para mostrar cómo se gestionan las comprobaciones de parámetros nulos en C#. Elimina el código repetitivo y declara una variable de cadena anulable:

string? info = null;

string? info = null;

Este objeto nulo representa un escenario en el que una llamada a un método puede recibir un argumento que no se ha instanciado correctamente. A continuación, Tim define un método sencillo:

void SayHi(string message)
{
    Console.WriteLine($"Hola {message}");
}

void SayHi(string message)
{
    Console.WriteLine($"Hola {message}");
}

Pasa la variable info al método:

SayHi(info);

SayHi(info);

Cuando el programa se ejecuta, la salida simplemente muestra:

Hola

No se produce ninguna excepción porque la concatenación de cadenas acepta un valor nulo y lo trata como una cadena vacía. Pero, como señala Tim, en la mayoría de los métodos del mundo real, esto puede causar situaciones propensas a errores en las que una referencia nula conduce a problemas posteriores o a una NullReferenceException más adelante en la pila de llamadas.

Para hacer un código robusto, los desarrolladores deben validar los argumentos y asegurarse de que cualquier método espera una entrada válida y no nula.

Comprobación nula tradicional antes de C# 10

Tim explica que antes de C# 10, la buena práctica era comprobar manualmente los parámetros y lanzar una ArgumentNullException cuando fuera necesario. Dentro del método SayHi, añade:

if (message is null)
    throw new ArgumentNullException(nameof(message));

if (message is null)
    throw new ArgumentNullException(nameof(message));

Esta comprobación asegura que si se pasa un argumento nulo, el programa lanza inmediatamente una nueva instancia de la clase ArgumentNullException.

Cuando Tim ejecuta el código, el mensaje de error se muestra claramente:

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

Esta excepción no manejada indica que el método recibió un argumento no válido. El nombre del parámetro -en este caso, "message"- se muestra automáticamente en la salida, lo que ayuda al desarrollador a identificar exactamente qué argumento causó el problema.

Tim señala que esta revisión del manual funciona perfectamente en .NET Framework y versiones anteriores de .NET Core. Sin embargo, es verbosa y repetitiva cuando se trata de múltiples parámetros. Cada parámetro adicional que necesita validación añade tres o cuatro líneas de código, saturando el cuerpo del método.

El Enfoque Simplificado en C# 10 - ArgumentNullException.ThrowIfNull()

En este punto, Tim introduce la sintaxis moderna de C# 10. En lugar de escribir varias líneas para cada parámetro, los desarrolladores ahora pueden escribir una sola línea de comprobación de nulos:

ArgumentNullException.ThrowIfNull(message);

ArgumentNullException.ThrowIfNull(message);

Tim explica que este "one-liner" realiza internamente la misma lógica de validación. Si el argumento pasado es nulo, el método lanza una excepción automáticamente, igual que antes, pero con una sintaxis mucho más limpia.

Cuando el programa se ejecuta de nuevo, aparece la siguiente salida:

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

El comportamiento sigue siendo idéntico, pero ahora se simplifica la sintaxis. No es necesario instanciar manualmente un nuevo objeto ArgumentNullException mediante un constructor ni especificar manualmente el parámetro paramName. El compilador deduce automáticamente el nombre del parámetro de llamada.

Tim subraya que esta mejora ahorra tiempo y reduce la posibilidad de que se produzcan errores humanos al hacer referencia a un nombre de parámetro incorrecto.

Ejemplo: Parámetros múltiples

A continuación, Tim compara el método tradicional con el nuevo a la hora de manejar múltiples parámetros.

Antes de C# 10, un desarrollador podría escribir:

if (name is null)
    throw new ArgumentNullException(nameof(name));
if (email is null)
    throw new ArgumentNullException(nameof(email));
if (password is null)
    throw new ArgumentNullException(nameof(password));

if (name is null)
    throw new ArgumentNullException(nameof(name));
if (email is null)
    throw new ArgumentNullException(nameof(email));
if (password is null)
    throw new ArgumentNullException(nameof(password));

Con la mejora de C# 10, las mismas comprobaciones pueden escribirse ahora de forma más sucinta:

ArgumentNullException.ThrowIfNull(name);
ArgumentNullException.ThrowIfNull(email);
ArgumentNullException.ThrowIfNull(password);

ArgumentNullException.ThrowIfNull(name);
ArgumentNullException.ThrowIfNull(email);
ArgumentNullException.ThrowIfNull(password);

Esta mejora no se limita a reducir el número de líneas, sino que hace que los métodos sean más limpios, más legibles y más fáciles de mantener. Tim señala que si su método espera tres parámetros, ahora sólo necesita tres comprobaciones de nulos, en lugar de doce líneas de código.

Por qué es importante - Código más seguro y robusto

Tim señala que, aunque pasar manualmente null a una cadena en una demostración puede no ser realista, representa problemas del mundo real. Las API, las entradas de usuario, los procesos de deserialización o las operaciones de devolución de objetos pueden generar objetos nulos de forma inesperada.

Al añadir comprobaciones de nulos al principio de un método, se previene un comportamiento inesperado y se falla rápidamente, lo que significa que el programa lanza una excepción al principio de la pila de llamadas antes de que el problema se propague.

También menciona que esta nueva sintaxis ayuda a mantener patrones coherentes de gestión de errores en todos los métodos. Anima a escribir código robusto que sea resistente a entradas no válidas y objetos sin fundamento.

Detalles de la excepción ArgumentNullException

Tim destaca que ArgumentNullException forma parte del espacio de nombres System y hereda de la clase ArgumentException. Se lanza cuando se pasa una referencia nula a un método que no la acepta como argumento válido.

Normalmente incluye:

• El nombre del parámetro que causó el problema.

• Un mensaje de error claro: "El valor no puede ser nulo"

• La pila de llamadas, que muestra dónde se ha producido la excepción.

El ejemplo de Tim demuestra cómo .NET 6 sigue este comportamiento al tiempo que mejora la sintaxis.

También señala brevemente que los desarrolladores pueden combinar estas comprobaciones con otras funciones, como el operador de coalescencia nula (??) o los valores por defecto, para proporcionar una lógica alternativa, por ejemplo:

message ??= "Default message";

message ??= "Default message";

Esto permite que un método asigne un valor por defecto en lugar de lanzar, si se desea.

Importancia de la comprobación nula en la gestión de errores

Tim recuerda a los desarrolladores que, aunque C# admite ahora tipos de referencia anulables, las comprobaciones de nulos en tiempo de ejecución siguen siendo esenciales. El compilador no puede detectar todos los problemas de referencias nulas, especialmente cuando los datos proceden de fuentes externas o de métodos fuera de su control.

Subraya que es una buena práctica comprobar los argumentos y lanzar una ArgumentNullException cuando proceda, asegurándose de que el método sólo se ejecuta cuando las entradas son válidas. Esto minimiza los errores en tiempo de ejecución, simplifica la gestión de errores y evita fallos silenciosos.

Resumen y perspectivas

Como conclusión, Tim señala que C# 11 introducirá aún más mejoras, pero por ahora, ArgumentNullException.ThrowIfNull() es una de las mejores pequeñas mejoras para la gestión de errores y la seguridad del código en .NET 6.

Anima a los desarrolladores a probar este enfoque en sus propios proyectos y comprobar cuánto más limpios parecen sus métodos. Termina con una pregunta: "¿Qué opinas de este cambio en C# 10?"

Reflexiones finales

El vídeo de Tim Corey deja claro que el método ArgumentNullException.ThrowIfNull() es una mejora sencilla pero potente en C# 10. Reduce el código manual propenso a errores y permite que los desarrolladores puedan utilizar el código de forma manual. Reduce el código manual propenso a errores, asegura argumentos válidos y hace que sus programas fallen rápidamente cuando se pasa un argumento nulo.

Mediante el uso sistemático de este método, los desarrolladores pueden crear código robusto, legible y fácil de mantener que gestiona las excepciones de forma limpia y evita los sutiles errores de referencia nula.

En resumen, siempre que su método espere un parámetro válido y quiera evitar argumentos nulos, siga el ejemplo de Tim Corey y utilice:

ArgumentNullException.ThrowIfNull(parameterName);

ArgumentNullException.ThrowIfNull(parameterName);

Se trata de una forma más limpia, segura y moderna de proteger el código de valores nulos y errores de ejecución en .NET 6 y versiones posteriores.