Entendendo o operador de coalescência nula em C#

Introdução

No início do vídeo, Gerald apresenta o operador de coalescência nula como um recurso poderoso do C# que reduz significativamente o número de linhas de código necessárias para a verificação de valores nulos. Ele enfatiza que esse operador simplifica as verificações condicionais e torna o código mais legível. Para ilustrar seus benefícios, Gerald apresenta um aplicativo de exemplo onde implementa e explica vários casos de uso do operador de coalescência nula.

Exemplo de esboço de aplicativo

Gerald começa configurando um aplicativo de console simples. Ele menciona que, em vídeos anteriores, usou o site .NET para demonstrações, mas devido a limitações de versão (compatível apenas com C# 7), ele passou a usar o Visual Studio para Mac. Ele garante que os exemplos também funcionarão no Visual Studio para Windows.

Para preparar a demonstração, Gerald cria uma classe básica Person com uma única propriedade Name:

public class Person 
{
    public string Name { get; set; }
}

public class Person 
{
    public string Name { get; set; }
}

Em seguida, ele inicializa uma instância dessa classe para demonstrar como o operador de coalescência nula funciona em cenários do mundo real.

Substituir verificação de nulo por operador de coalescência de nulos (??)

Gerald agora demonstra como o operador de coalescência nula (??) pode ser usado para simplificar a lógica de verificação de nulos. Ele atribui nulo à propriedade Name e então usa ?? Para fornecer um valor alternativo:

var name = person.Name ?? "Gerald";

var name = person.Name ?? "Gerald";

Gerald explica que, antes desse operador, os desenvolvedores usavam uma instrução if:

string name;
if (person.Name == null)
{
    name = "Gerald";
}
else
{
    name = person.Name;
}

string name;
if (person.Name == null)
{
    name = "Gerald";
}
else
{
    name = person.Name;
}

Usando ??, essa lógica é reduzida a uma única linha. Quando person.Name é nulo, 'Gerald' é atribuído; caso contrário, person.Name retém seu valor. Ele executa o programa e confirma que a saída está correta.

Coalescência nula para lançar exceções

Em seguida, Gerald explora outro caso de uso: lançar exceções usando o operador de coalescência nula. Em vez de fornecer um valor alternativo, ele demonstra como lançar uma exceção ao encontrar um valor nulo:

var name = person.Name ?? throw new ArgumentNullException(nameof(person.Name), "Name cannot be null");

var name = person.Name ?? throw new ArgumentNullException(nameof(person.Name), "Name cannot be null");

Gerald destaca que isso é particularmente útil ao trabalhar com parâmetros de método ou propriedades onde valores nulos não devem ser permitidos. Ele explica que esse recurso foi introduzido no C# 7 ou 8, dependendo das configurações do projeto. Executar o código com um valor nulo para person.Name resulta em um ArgumentNullException, efetivamente prevenindo referências nulas não intencionais.

Atribuição de composto coalescente nulo (??=)

Gerald passa a discutir o operador de atribuição composta coalescente nula (??=), que fornece uma maneira ainda mais simplificada de atribuir valores padrão. Em vez de escrever:

if (person.Name == null)
{
    person.Name = "Gerald";
}

if (person.Name == null)
{
    person.Name = "Gerald";
}

Ele simplifica isso com:

person.Name ??= "Gerald";

person.Name ??= "Gerald";

Gerald explica que ??= atribui o valor especificado somente se o operando à esquerda for nulo. Se person.Name já tiver um valor, ele permanece inalterado. Este operador é particularmente útil para inicializar campos ou garantir que as variáveis ​​nunca permaneçam nulas.

Combinando com o operador condicional nulo

Na seção final, Gerald demonstra como o operador de coalescência nula pode ser combinado com o operador condicional nulo (?.). O operador condicional nulo permite acesso seguro às propriedades sem causar um NullReferenceException. Ele fornece um exemplo:

var length = person?.Name?.Length ?? 0;

var length = person?.Name?.Length ?? 0;

Gerald explica que isso garante que, se person ou Name for nulo, o resultado padrão será 0 em vez de lançar uma exceção. Essa combinação é útil ao trabalhar com tipos de referência anuláveis ​​ou hierarquias de objetos complexas.

Conclusão

Ao longo do vídeo, Gerald Versluis explica de forma eficaz o poder do operador de coalescência nula (??) e da atribuição composta de coalescência nula (??=). Ele demonstra como esses operadores podem substituir as verificações de nulo tradicionais, tornando o código mais conciso e legível. Ao aproveitar esses recursos, os desenvolvedores podem escrever aplicativos C# mais limpos e eficientes.

Se você estiver interessado em ver esses conceitos em ação, confira o vídeo completo de Gerald Versluis sobre "Entendendo o operador de coalescência nula em C# (?? e ??=)."