C# Academy · Aula

Protegendo contra nulos

Validação e padrões.

Protegendo contra nulos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 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.

Por que proteger contra nulos?

Um método que recebe um null inesperado geralmente falha mais tarde com uma NullReferenceException confusa, em uma parte profunda da pilha de chamadas.

Proteger significa verificar os argumentos logo no início e falhar de forma clara, para que o erro aponte diretamente para a causa real.

Verificação nula clássica

A proteção mais simples é uma verificação explícita que lança uma ArgumentNullException quando um argumento obrigatório é nulo.

Isso valida a entrada no limite do seu método, antes que qualquer trabalho comece.

void Save(string path)
{
    if (path == null)
        throw new System.ArgumentNullException(nameof(path));
    System.Console.WriteLine(path);
}

Use nameof

Passe nameof(path) em vez de uma cadeia de caracteres codificada diretamente. A exceção informará o nome exato do parâmetro e continuará correto se você renomear o parâmetro.

Isso facilita muito a depuração quando a exceção é registrada.

void Greet(string user)
{
    if (user is null)
        throw new System.ArgumentNullException(nameof(user));
    System.Console.WriteLine("Hi " + user);
}

Auxiliar ThrowIfNull

O C# moderno oferece ArgumentNullException.ThrowIfNull(arg). Ele verifica se o valor é nulo e lança uma exceção com o nome correto do parâmetro automaticamente.

Essa forma é concisa e constitui o estilo de proteção preferido no código atual do .NET.

void Process(object data)
{
    System.ArgumentNullException.ThrowIfNull(data);
    System.Console.WriteLine("Processing");
}

Uma proteção executável

Este programa mostra uma proteção identificando um argumento nulo e informando o problema de forma clara, em vez de falhar mais tarde.

Execute-o para ver a mensagem da exceção identificando o parâmetro inválido.

using System;

class Program
{
    static void Print(string text)
    {
        ArgumentNullException.ThrowIfNull(text);
        Console.WriteLine(text);
    }

    static void Main()
    {
        try { Print(null); }
        catch (ArgumentNullException ex) { Console.WriteLine(ex.ParamName); }
    }
}

Proteja com ?? throw

Você pode combinar atribuição e proteção usando ?? com throw. Isso valida e armazena o valor em uma única linha.

Esse é um padrão comum em construtores ao atribuir um valor a um campo.

class Service
{
    private readonly string _name;
    public Service(string name)
        => _name = name ?? throw new System.ArgumentNullException(nameof(name));
}

Vazio versus nulo

Para cadeias de caracteres, nulo e vazio são problemas diferentes. Use string.IsNullOrEmpty ou string.IsNullOrWhiteSpace para identificar ambos de uma só vez.

Uma ArgumentException (não uma ArgumentNullException) é apropriada para um valor vazio, mas não nulo.

void SetName(string name)
{
    if (string.IsNullOrWhiteSpace(name))
        throw new System.ArgumentException("Name required", nameof(name));
}

Protegendo com padrões

Os padrões is null e is not null são claros e não podem ser enganados por operadores de igualdade sobrecarregados.

Prefira is null a == null quando um tipo puder substituir ==.

object value = null;
if (value is null)
    System.Console.WriteLine("It is null");
if (value is not null)
    System.Console.WriteLine("Has value");

Usando um valor padrão em vez de lançar uma exceção

Nem todo valor nulo é um erro. Às vezes, um valor padrão adequado é melhor do que uma exceção.

Use ?? quando o valor nulo for aceitável e lance uma exceção somente quando o valor for realmente obrigatório.

string BuildPath(string folder)
{
    folder ??= "/tmp";
    return folder + "/file.txt";
}

Os tipos de referência anuláveis ajudam

Com os tipos de referência anuláveis habilitados, o compilador avisa quando você pode desreferenciar um valor possivelmente nulo, identificando falhas antes do tempo de execução.

Declarar string (não nulo) em vez de string? (anulável) documenta sua intenção e orienta o analisador.

#nullable enable
string required = "ok";
string? optional = null;
System.Console.WriteLine(optional?.Length ?? 0);

Proteja e use com segurança

Depois de proteger o valor no início de um método, o restante do corpo pode usá-lo sem verificações repetidas de nulo.

Este programa protege o valor e depois usa o argumento com segurança.

using System;

class Program
{
    static int Length(string s)
    {
        ArgumentNullException.ThrowIfNull(s);
        return s.Length;
    }

    static void Main()
    {
        Console.WriteLine(Length("hello"));
    }
}

Verificação rápida

Teste sua compreensão da proteção contra nulos.

Recapitulação

Proteja os argumentos obrigatórios no início de um método. Use ArgumentNullException.ThrowIfNull ou ?? throw com nameof para obter erros claros.

Use string.IsNullOrWhiteSpace para cadeias vazias, os padrões is null para verificações seguras e ?? quando um valor padrão for aceitável em vez de falhar.

Perguntas Frequentes

A aula “Protegendo contra nulos” é grátis?

Sim — o texto completo de “Protegendo contra nulos” é 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 “Protegendo contra nulos”?

Validação e padrões. 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 4 de 4.

Quanto tempo leva a aula “Protegendo contra nulos”?

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

← Voltar para C# Academy