Lanzar una excepción desde el operador ?? de C#

Los programadores somos a veces seres comodones, no es que seamos vagos ni tampoco que huyamos del esfuerzo, pero si podemos evitarnos alguna que otra línea de código al mismo tiempo que hacemos algo más simple,… como que nos gusta.

Lo que quiero contar en esta entrada es como utilizar el operador ?? de C# para devolver desde el mismo operador, una excepción.

Pero antes de todo, pongámonos en situación, y luego, apliquemos alguna mejora o ajuste que nos permita realizar lo que queramos.

Partamos de un código base general, modelo a partir del cuál explicamos la situación de inicio, y lo que deseamos realizar.

He creado un proyecto de aplicación de consola con C#, sobre el que he escrito el siguiente código (forzado para demostrar de forma rápida y sencilla la base de partida):

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Started");

        try
        {
            string demo = null;
            Console.WriteLine(Foo(demo));
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }

        Console.WriteLine("Press any key to close");
        Console.ReadKey();
    }

    private static string Foo(string data)
    {
        if (data == null)
        {
            throw new ArgumentNullException();
        }

        return data;
    }

}

Como vemos, un código muy claro y sencillo.

Forzamos aquí, que el parámetro de entrada a la función Foo sea un valor null para que lance la excepción.

Pero lo que quiero hacer realmente en la función Foo, es utilizar el operador ?? para simplificar más aún el código.

Sin embargo, al devolver una excepción por un lado, y un valor (el del parámetro de entrada en este ejemplo si no es null) por otro lado, el uso del operador ?? no es posible.

¿Cómo podríamos utilizar el operador ?? ?.

Se me ocurre una solución, que consiste en crear y llamar a una función que se encargue de lanzar una excepción en el caso de que el valor pasado sea null, y el valor en caso contrario.

El código de nuestro ejemplo en lo que concierne a la parte que cambia, quedaría de esta forma:

private static string Foo(string data)
{
    return data ?? ThrowException<string>();
}

    private static T ThrowException<T>()
    {
            throw new ArgumentNullException();
    }

En este caso, sí podremos usar el operador ??.

Es en realidad un truco de cómo usarlo.

Otra solución que podríamos aportar, aunque sin usar el operador ??, pero igualmente limpia y elegante, es utilizar extensiones para lograr nuestro propósito.

Para hacer o demostrar esto, crearé primero una extensión.

He creado un archivo de código que he denominado como ExceptionExtensions.

El código de esta clase es el que indico a continuación:

public static class ExceptionExtensions
{
    public static T ThrowIfNull<T>(this T @object, string paramName = "") where T : class
    {
        if (@object == null)
        {
            if (!String.IsNullOrEmpty(paramName))
            {
                throw new ArgumentNullException(paramName);
            }

            throw new ArgumentNullException();
        }

        return @object;
    }
}

A continuación, escribiremos el código que se encarga de consumir esta extensión.

Respecto al código que nos importa destacar, éste quedaría en este caso de la siguiente forma:

private static string Foo(string data)
{
    return (data).ThrowIfNull();
}

Son diferentes aproximaciones, que quería compartir.

Obviamente hay más posibles soluciones, pero espero como podemos ver, algunas son además de simples, reutilizables.

¡Happy Coding!