0Pricing
C# Academy · Aula

Operadores condicionais e de coalescência de nulo

Combine ?., ?[], ?? e ??= para escrever código conciso e seguro contra nulos, sem verificações extensas.

Operadores condicionais e de coalescência de nulo é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Padrões de código seguro contra nulos

O C# fornece três operadores específicos para tratar valores nulos de forma concisa: o operador condicional de nulo (?., ?[]), o operador de coalescência de nulo (??) e o operador de atribuição por coalescência de nulo (??=). Juntos, eles eliminam a maior parte do código repetitivo de verificações de nulo.

Operador condicional de nulo: ?.

?. retorna imediatamente null se o lado esquerdo for null, em vez de lançar uma exceção NullReferenceException. O tipo do resultado se torna anulável.

User? user = GetUser(id);

// Without ?.:
string? name = null;
if (user != null) name = user.Name;

// With ?.:
string? name2 = user?.Name;

// Chained:
string? city = user?.Address?.City;

// Method call:
string? upper = user?.Name?.ToUpper();

Condicional de nulo com acesso por índice: ?[]

?[] é o operador de índice condicional de nulo. Ele acessa com segurança elementos de arrays ou coleções quando a própria coleção pode ser nula.

List<string>? tags = product?.Tags;

// Safe index access
string? firstTag = tags?[0];

// Null-conditional LINQ
int? count = tags?.Count;
bool? hasItems = tags?.Any();

// With methods:
string? joined = tags?.FirstOrDefault()?.ToUpper();

Operador de coalescência de nulo: ??

?? retorna o operando esquerdo se ele não for nulo; caso contrário, retorna o operando direito (a alternativa). É a substituição concisa para x != null ? x : fallback.

string? name = GetName();

// Without ??:
string display = name != null ? name : "Anonymous";

// With ??:
string display2 = name ?? "Anonymous";

// Chaining ?? for multiple fallbacks:
string result = primary ?? secondary ?? tertiary ?? "Default";

// Combining with ?.
string city = user?.Address?.City ?? "Unknown City";

Atribuição com coalescência de nulo: ??=

??= atribui o lado direito à variável somente se ela for nula no momento. É ideal para padrões de inicialização tardia.

// Lazy initialization
private List<string>? _cache;

public List<string> GetCache()
{
    _cache ??= new List<string>(); // only assigns if null
    return _cache;
}

// Equivalent to:
// if (_cache is null) _cache = new List<string>();

// In-place:
string? name = null;
name ??= "Default";
Console.WriteLine(name); // "Default"

Usando ?. com eventos

O operador condicional de nulo é a forma padrão e segura para uso em várias linhas de execução ao invocar eventos — ele evita a condição de corrida entre uma verificação separada de nulo e a invocação.

public event EventHandler<DataEventArgs>? DataReceived;

// Thread-safe event invocation:
DataReceived?.Invoke(this, new DataEventArgs(data));

// This is equivalent to:
var handler = DataReceived;
if (handler != null) handler(this, new DataEventArgs(data));
// (local copy avoids race condition between check and invoke)

Exemplos complexos de encadeamento

A combinação de operadores permite uma navegação limpa, legível e segura contra nulos por grafos de objetos profundamente aninhados.

var order = GetOrder(id);

// Deeply nested with fallbacks:
string countryCode = order
    ?.Customer
    ?.ShippingAddress
    ?.Country
    ?.Code
    ?? "US";

// Collection safe access:
decimal firstLineTotal = order
    ?.Lines
    ?.FirstOrDefault()
    ?.Total
    ?? 0m;

// Method chain:
string? trackingUpper = order?.TrackingNumber?.ToUpper().Trim();

Condicional de nulo em LINQ

O operador condicional de nulo funciona perfeitamente com LINQ, permitindo consultas seguras em coleções ou propriedades que podem ser nulas.

List<Order>? orders = customer?.Orders;

// Safe LINQ on a nullable collection:
var totalRevenue = orders?.Sum(o => o.Total) ?? 0m;
var pendingCount = orders?.Count(o => o.Status == OrderStatus.Pending) ?? 0;
var latest       = orders?.MaxBy(o => o.PlacedAt)?.Id;

Guardas contra nulos com ThrowIfNull

Para parâmetros que não podem ser nulos, use ArgumentNullException.ThrowIfNull() (.NET 6+) para realizar uma validação concisa e descritiva na entrada do método.

public void ProcessOrder(Order order, Customer customer)
{
    ArgumentNullException.ThrowIfNull(order);
    ArgumentNullException.ThrowIfNull(customer);

    // From this point, compiler knows both are non-null
    Console.WriteLine(order.Id);
    Console.WriteLine(customer.Name);
}

// .NET 7+: ArgumentException.ThrowIfNullOrEmpty
void Save(string name)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(name);
    // name is guaranteed non-empty
}

Padrão de não nulo em expressões de seleção

A correspondência de padrões com is not null e is { } oferece padrões limpos para verificar nulos, especialmente em expressões de seleção.

string Describe(object? obj) => obj switch
{
    null                          => "nothing",
    string s when s.Length == 0  => "empty string",
    string s                      => $"string: {s}",
    int i                         => $"integer: {i}",
    { }                           => $"object: {obj.GetType().Name}"
};

// is not null in if statements:
if (order is not null && order.Customer is { Name: var name })
    Console.WriteLine(name);

Verificação rápida

O que a expressão user?.Name ?? "Anonymous" retorna quando user é nulo?

Recapitulação: condicional de nulo e coalescência de nulo

Principais conclusões:

  • ?.: acesso seguro a membros — retorna nulo em vez de lançar uma exceção quando o receptor é nulo
  • ?[]: acesso seguro a índices em coleções potencialmente nulas
  • ??: valor alternativo quando o operando esquerdo é nulo
  • ??=: atribui somente quando é nulo — ideal para inicialização tardia
  • Encadeie-os: a?.B?.C ?? defaultVal para uma navegação profunda e segura contra nulos
  • ArgumentNullException.ThrowIfNull() para guardas de validação de parâmetros

Perguntas Frequentes

A aula “Operadores condicionais e de coalescência de nulo” é grátis?

Sim — o texto completo de “Operadores condicionais e de coalescência de nulo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Operadores condicionais e de coalescência de nulo”?

Combine ?., ?[], ?? e ??= para escrever código conciso e seguro contra nulos, sem verificações extensas. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Operadores condicionais e de coalescência de nulo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Ativação e compreensão de NRT
  2. Anotações: ?, !, MaybeNull e NotNull
  3. Operadores condicionais e de coalescência de nulo
  4. Migrando uma base de código para NRT
← Voltar para C# Academy