C#. Passado, presente e futuro

Verificando parâmetros nulos

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.

Elemar Júnior

Microsoft Regional Director e Microsoft MVP. Atua, há mais de duas décadas, desenvolvendo software e negócios digitais de classe mundial. Teve o privilégio de ajudar a mudar a forma como o Brasil vende, projeta e produz móveis através de software. Hoje, seus interesses técnicos são arquiteturas escaláveis. bancos de dados e ferramentas de integração. Além disso, é fascinado por estratégia e organizações exponenciais.

Talvez você goste também

Carregando posts…

Mais posts da série C#. Passado, presente e futuro

2 Comentários
  1. Carlos

    Elemar, muito obrigado pelo artigo.
    A cada nova evolução do C# a sintaxe fica mais enxuta e menos verbosa.

  2. RENATO

    Interessante, será que haverá uma forma de fazer uma sobrecarga desse operador? Útil para lançar outra exceção.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *