Entendendo o operador de coalescência nula em C#

O operador de coalescência nula (??) em C# permite que os desenvolvedores simplifiquem a lógica de verificação de nulos, reduzindo a verbosidade do código e melhorando a legibilidade. Em vez de escrever longas condições if-else, este operador fornece uma maneira concisa de atribuir valores alternativos quando um valor nulo é encontrado. Neste artigo, exploraremos detalhadamente o operador de coalescência nula acompanhando o vídeo de Gerald Versluis, "[** Entendendo o operador de coalescência nula em C# (?? e ??=)** Vamos analisar as seções principais do vídeo e como Gerald demonstra esse recurso útil do 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; }
}

Public Class Person
    Public Property Name As String
End Class

Public Class Person
    Public Property Name As String
End Class

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 null à propriedade Name e então usa ?? Para fornecer um valor alternativo:

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

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

Dim name As String = If(person.Name, "Gerald")

Dim name As String = If(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;
}

Dim name As String
If person.Name Is Nothing Then
    name = "Gerald"
Else
    name = person.Name
End If

Dim name As String
If person.Name Is Nothing Then
    name = "Gerald"
Else
    name = person.Name
End If

Ao usar ??, essa lógica é reduzida a uma única linha. Quando person.Name é null, "Gerald" é atribuído; caso contrário, person.Name manté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");

Dim name As String = If(person.Name, Throw New ArgumentNullException(NameOf(person.Name), "Name cannot be null"))

Dim name As String = If(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 null 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";
}

If person.Name Is Nothing Then
    person.Name = "Gerald"
End If

If person.Name Is Nothing Then
    person.Name = "Gerald"
End If

Ele simplifica isso com:

person.Name ??= "Gerald";

person.Name ??= "Gerald";

person.Name = If(person.Name, "Gerald")

person.Name = If(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 a propriedades sem causar um NullReferenceException. Ele fornece um exemplo:

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

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

Dim length As Integer = If(person?.Name?.Length, 0)

Dim length As Integer = If(person?.Name?.Length, 0)

Gerald explica que isso garante que se person ou Name for null, o resultado seja padronizado para 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 ??=)."