C# Academy · Aula

Expressões switch; verificações exaustivas com when (emulação no C# 6)

Expressões switch; verificações exaustivas com when (emulação no C# 6) é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 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.

Plano: imitação de switch

Objetivo: Imitar expressões switch modernas no C# 6.

Retorne valores usando o switch clássico
Faça uma verificação prévia com proteções
Falhe rapidamente usando default throw para garantir que todos os casos sejam tratados

Switch que retorna um valor

Uma seleção que retorna um valor funciona como uma expressão de seleção. O lançamento de exceção no caso padrão captura valores desconhecidos.

using System;

public enum Grade { A, B, C, D, F }

public class Program
{
  static string Describe(Grade g)
  {
    switch (g)
    {
      case Grade.A: return "Excellent";
      case Grade.B: return "Good";
      case Grade.C: return "Average";
      case Grade.D: return "Below average";
      case Grade.F: return "Fail";
      default: throw new ArgumentOutOfRangeException("g");
    }
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(Describe(Grade.A));
    Console.WriteLine(Describe(Grade.F));
  }
}

“quando” por meio de guardas

Use verificações de guarda para simular cláusulas de quando. Valide primeiro as entradas e, depois, ramifique por intervalos.

using System;

public class Program
{
  // Emulate: switch(score) { case var s when s >= 90: ... } using pre-guards
  static string LabelScore(int score)
  {
    if (score < 0 || score > 100) throw new ArgumentOutOfRangeException("score");

    if (score >= 90) return "A";
    if (score >= 80) return "B";
    if (score >= 70) return "C";
    if (score >= 60) return "D";
    return "F";
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(LabelScore(92)); // A
    Console.WriteLine(LabelScore(77)); // C
  }
}

Auxiliar de exaustividade

Adicione um pequeno auxiliar Exhaustive.Unhandled e chame-o no caso padrão. Os testes falharão quando um novo valor da enumeração não for tratado.

using System;

public enum Status { New, Active, Closed }

public static class Exhaustive
{
  public static Exception Unhandled(object x)
  {
    return new InvalidOperationException("Unhandled case: " + x);
  }
}

public class Program
{
  static int ToHttp(Status s)
  {
    switch (s)
    {
      case Status.New: return 201;
      case Status.Active: return 200;
      case Status.Closed: return 410;
      default: throw Exhaustive.Unhandled(s);
    }
  }

  public static void Main(string[] args)
  {
    Console.WriteLine(ToHttp(Status.Active)); // 200
  }
}

Guardas + seleção pelo tipo

Valide os dados de cada ramo com guardas preliminares e, depois, selecione pelo discriminador. Isso reproduz o comportamento de “quando” nos casos.

using System;

public enum ShapeKind { Circle, Square }

public sealed class Shape
{
  public ShapeKind Kind;
  public double Radius; // for circle
  public double Side;   // for square
}

public class Program
{
  static double Area(Shape s)
  {
    if (s == null) throw new ArgumentNullException("s");

    // “when” guards (validate needed fields)
    if (s.Kind == ShapeKind.Circle && s.Radius < 0) throw new ArgumentException("Radius must be >= 0");
    if (s.Kind == ShapeKind.Square && s.Side < 0) throw new ArgumentException("Side must be >= 0");

    switch (s.Kind)
    {
      case ShapeKind.Circle: return Math.PI * s.Radius * s.Radius;
      case ShapeKind.Square: return s.Side * s.Side;
      default: throw new InvalidOperationException("Unhandled shape: " + s.Kind);
    }
  }

  public static void Main(string[] args)
  {
    Shape c = new Shape { Kind = ShapeKind.Circle, Radius = 2.0 };
    Console.WriteLine("Area circle = " + Area(c));
  }
}

Dicas e armadilhas

Dicas:

Prefira métodos pequenos que retornem valores, com responsabilidade única
Mantenha o caso padrão lançando uma exceção para revelar cedo os casos ausentes
Coloque as guardas antes da seleção; elas funcionam como condições de quando

Simulação da exaustividade

Verificação rápida: no C# 6, como simular um tratamento exaustivo com seleção, de modo semelhante a uma expressão de seleção com quando?

Recapitulação

Recapitulação: Retorne de uma seleção clássica como em uma expressão de seleção, adicione guardas para simular “quando” e mantenha um lançamento de exceção no caso padrão para revelar os casos ausentes.

Perguntas Frequentes

A aula “Expressões switch; verificações exaustivas com when (emulação no C# 6)” é grátis?

Sim — o texto completo de “Expressões switch; verificações exaustivas com when (emulação no C# 6)” é 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 “Expressões switch; verificações exaustivas com when (emulação no C# 6)”?

Emule expressões switch com métodos clássicos que retornam a partir de switch, adicione verificações de proteção e use lançamentos padrão para detectar casos não tratados durante a execução. 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 2 de 3.

Quanto tempo leva a aula “Expressões switch; verificações exaustivas com when (emulação no C# 6)”?

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

Padrões is; padrões relacionais e lógicos (emulação no C# 6)
Expressões switch; verificações exaustivas com when (emulação no C# 6)
Modelagem de domínio com uniões discriminadas (registros) — emulação no C# 6

← Voltar para C# Academy