0Pricing
C# Academy · Aula

Padrões de proteção e validação

Valide as entradas antecipadamente com cláusulas de proteção, lance as exceções corretas e use verificações no estilo de TryParse para dados do usuário.

Padrões de proteção e validação é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 3. 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 3 aulas no total.

Por que usar proteções

Objetivo: manter os métodos seguros e legíveis.

  • Use cláusulas de proteção no início
  • Lance exceções específicas (ArgumentNullException, ArgumentOutOfRangeException)
  • Use TryParse para a entrada do usuário
  • Falhe rapidamente; evite aninhamentos profundos

Demonstração de proteções antecipadas

Adicione pequenas verificações no início para validar os argumentos; lance exceções específicas para que os chamadores saibam o que deu errado.

using System;

// Demo: validate inputs at the top; keep main logic flat.
public class Program
{
  // Compute price with simple rules; guard early.
  public static decimal ComputePrice(string sku, int qty, decimal unitPrice)
  {
    if (sku == null) throw new ArgumentNullException("sku");
    if (sku.Length == 0) throw new ArgumentException("sku must not be empty", "sku");
    if (qty <= 0) throw new ArgumentOutOfRangeException("qty", "qty must be > 0");
    if (unitPrice < 0m) throw new ArgumentOutOfRangeException("unitPrice", "unitPrice must be >= 0");

    // Main logic stays simple
    decimal subtotal = qty * unitPrice;
    if (qty >= 10) subtotal = subtotal * 0.9m; // small bulk discount
    return subtotal;
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(ComputePrice("ABC", 2, 5m));   // ok
    try { Console.WriteLine(ComputePrice("", 2, 5m)); } catch (Exception ex) { Console.WriteLine(ex.GetType().Name); }
  }
}

Classe auxiliar Guard

Extraia verificações comuns para uma pequena classe Guard, mantendo os corpos dos métodos limpos e consistentes.

using System;

// Minimal static helper for common validations (beginner friendly).
public static class Guard
{
  public static void NotNull(object value, string name)
  {
    if (value == null) throw new ArgumentNullException(name);
  }

  public static void NotNullOrEmpty(string value, string name)
  {
    if (value == null) throw new ArgumentNullException(name);
    if (value.Length == 0) throw new ArgumentException(name + " must not be empty", name);
  }

  public static void InRange(int value, int minInclusive, int maxInclusive, string name)
  {
    if (value < minInclusive || value > maxInclusive)
      throw new ArgumentOutOfRangeException(name, "Expected " + minInclusive + ".." + maxInclusive);
  }
}

public class Program
{
  static int ScoreFor(string userId, int level)
  {
    Guard.NotNullOrEmpty(userId, "userId");
    Guard.InRange(level, 1, 10, "level");
    // pretend logic
    return level * 100;
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(ScoreFor("u42", 3));
    try { Console.WriteLine(ScoreFor(null, 3)); } catch (Exception ex) { Console.WriteLine(ex.GetType().Name); }
  }
}

Validação com TryParse

Para entradas inválidas rotineiras, prefira métodos no estilo de TryParse que retornem false em vez de lançarem exceções.

using System;

// Use TryParse for user-provided text; avoid throwing for normal invalid input.
public class Program
{
  public static bool TryGetPort(string text, out int port)
  {
    port = 0;
    int value;
    if (!int.TryParse(text, out value)) return false;
    if (value < 1 || value > 65535) return false;
    port = value;
    return true;
  }

  public static void Main(string[] args)
  {
    int p;
    Console.WriteLine("8080 -> " + (TryGetPort("8080", out p) ? ("ok " + p) : "invalid"));
    Console.WriteLine("abc -> " + (TryGetPort("abc", out p) ? ("ok " + p) : "invalid"));
  }
}

Lançar ou retornar

  • Lançar para erros do programador (uso incorreto da API, valor nulo quando não permitido, valor fora do intervalo)
  • Retornar false/Resultado para erros comuns do usuário (texto inválido)
  • Use tipos de exceção específicos; inclua o nome do parâmetro
  • Valide de fora para dentro: faça primeiro as verificações baratas

Boas práticas

Dicas:

  • Valide nas fronteiras (controladores, APIs públicas)
  • Prefira pequenos métodos de proteção a aninhamentos profundos
  • Mantenha as mensagens de erro curtas e claras
  • Registre uma vez na fronteira, não em cada proteção

Significado de cláusula de proteção

Verificação rápida: qual opção descreve melhor uma cláusula de proteção?

Recapitulação

Recapitulação: valide antecipadamente com cláusulas de proteção, lance exceções específicas para erros do programador e use TryParse para a entrada cotidiana do usuário.

Perguntas Frequentes

A aula “Padrões de proteção e validação” é grátis?

Sim — o texto completo de “Padrões de proteção e validação” é 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 3 aulas no total.

O que vou aprender em “Padrões de proteção e validação”?

Valide as entradas antecipadamente com cláusulas de proteção, lance as exceções corretas e use verificações no estilo de TryParse para dados do usuário. 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 3.

Quanto tempo leva a aula “Padrões de proteção e validação”?

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. Abstrações de registro, Debug/Trace
  2. Criação de perfis e rastreamentos básicos (conceitos)
  3. Padrões de proteção e validação
← Voltar para C# Academy