Referências nulas são uma verdadeira “dor de cabeça” para desenvolvedores .NET, tanto que, recentemente, o compilador de C# passou a suportar um modelo de desenvolvimento que não permite o uso de nulos.

Verificar parâmetros nulos sempre foi uma necessidade. Entretanto, a forma como essa verificação acontece tem mudado ao longo do tempo.

No passado, era necessário escrever condicionais explicitamente.

public class Foo
{
    private readonly object _a;
    private readonly object _b;

    public Foo(object a, object b)
    {
        if (a == null)
        {
            throw new ArgumentNullException(nameof(a));
        }
        _a = a;

        if (b == null)
        {
            throw new ArgumentNullException(nameof(b));
        }
        _b = b;
    }
    // ...
}

Recentemente, com o advento das throw expressions o código para esse tipo de verificação ficou mais conciso.

public class Foo
{
    private readonly object _a;
    private readonly object _b;

    public Foo(object a, object b)
    {
        _a = a ?? throw new ArgumentNullException(nameof(a));
        _b = b ?? throw new ArgumentNullException(nameof(b));
    }
    // ...
}

Entretanto, a partir do C# 9, uma nova sintaxe será introduzida especificamente para testar parâmetros.

public class Foo
{
    private readonly object _a;
    private readonly object _b;

    public Foo(object a!!, object b!!)
        => (_a, _b) = (a, b);
    
}

Segundo a última reunião do time de linguagem, um novo operador (!!) utilizável na lista de parâmetros será suficiente para que o compilador assuma o papel de “escrever ” a verificação necessária.

Gostamos da ideia de simplificar a forma como uma necessidade recorrente, como verificar a nulidade de parâmetros, é expressada em código. Entendemos que ela colabora com o aumento da produtividade. Entretanto, preocupa ver o ritmo com que a especificação da linguagem está crescendo.