Operador switch clássico

1. Introdução

Imagina que você é o barista de uma cafeteria bombada. Chega um cliente e fala um dos cinco drinks favoritos dele. Você não faz uma análise filosófica, só bate o olho no cardápio e responde rapidinho: “Capuccino? Claro! Tá aqui seu capuccino!”. Se você checasse cada opção com um if separado, seu código ia ficar igual pilha de xícara depois do rush do almoço — trambolho e nada prático.

O operador switch deixa você checar o valor de uma variável de forma elegante e executar ações diferentes dependendo do resultado. Ele só funciona com alguns tipos de dados (já já falo disso), mas pra maioria dos menus, comandos simples ou reconhecimento de status, é a ferramenta perfeita.

2. Sintaxe clássica do switch em C#

Aqui vai um fluxograma básico de como funciona:

switch (Expressão) {
    case Valor1:
        // ações
        break;
    case Valor2:
        // ações
        break;
    ...
    default:
        // ações padrão
        break;
}

Exemplo 1: menu clássico

Console.WriteLine("Escolha uma bebida: 1 - Café, 2 - Chá, 3 - Cacau");
string input = Console.ReadLine();
int choice = int.Parse(input);

switch (choice)
{
    case 1:
        Console.WriteLine("Você escolheu café. Boa escolha!");
        break;
    case 2:
        Console.WriteLine("Chá também é bom.");
        break;
    case 3:
        Console.WriteLine("Cacau é pra quem curte aconchego!");
        break;
    default:
        Console.WriteLine("Essa bebida não tá no cardápio.");
        break;
}

• O bloco switch checa se choice é igual aos valores depois do case.
• Depois de cada opção tem que ter break; — senão a execução vai cair no próximo case (já já explico isso).
• O bloco default é tipo um else; ele roda se nenhum case bater.

Como o switch funciona por dentro? — Passo a passo

1. Primeiro, a expressão entre parênteses depois do switch é avaliada (no nosso exemplo — a variável choice).
2. O programa compara ela com cada valor listado nos case, um por um.
3. Se bater — executa as instruções daquele bloco. Aí encontra o break e sai do switch.
4. Se não bater com nenhum case, executa o bloco default (se tiver).

Esquema visual

«+» — esse bloco é executado

3. Quais tipos o switch clássico suporta?

Na sintaxe clássica (ou seja, sem "Pattern Matching" e as novidades que a gente vai ver depois!) o switch aceita:

• Tipos inteiros simples (int, byte, char, long, short, sbyte, ushort, uint, ulong)
• Strings (string)
• Enums (enum)
• Caracteres (char)

Exemplo 2: switch com strings

Console.WriteLine("Escolha um comando: start, stop, pause");
string command = Console.ReadLine();

switch (command)
{
    case "start":
        Console.WriteLine("Programa iniciado!");
        break;
    case "stop":
        Console.WriteLine("Programa parado.");
        break;
    case "pause":
        Console.WriteLine("Programa em pausa.");
        break;
    default:
        Console.WriteLine("Comando desconhecido.");
        break;
}

4. Por que precisa do break e o que rola se esquecer?

O bug mais clássico de quem tá começando é esquecer o break; dentro do case. Bora ver o que acontece se você pular ele.

Exemplo 3: caindo no próximo bloco (fall-through)

int day = 2;

switch (day)
{
    case 1:
        Console.WriteLine("Segunda-feira");
        break;
    case 2:
        Console.WriteLine("Terça-feira");
    case 3:
        Console.WriteLine("Quarta-feira");
        break;
    default:
        Console.WriteLine("Dia desconhecido");
        break;
}

O que vai acontecer?

• O valor de entrada é day = 2.
• Primeiro executa a linha: "Terça-feira"
• Não tem break — a execução cai direto no case 3 e executa: "Quarta-feira"
• Aí encontra o break; — e sai.

Na tela vai aparecer:

Terça-feira
Quarta-feira

Esse é um erro clássico!

• Se você quer executar UMA ação só, coloca break; em cada case.
• Se (raramente) quiser que algumas opções rodem a mesma lógica, pode “colar” elas (veja abaixo).

5. Agrupando valores de case

Às vezes, vários valores precisam ter o mesmo comportamento. Pra que copiar o mesmo código?

Exemplo 4: mesma reação pra vários case

char grade = 'B';

switch (grade)
{
    case 'A':
    case 'B':
    case 'C':
        Console.WriteLine("Aprovado!");
        break;
    case 'D':
    case 'E':
        Console.WriteLine("Dá pra melhorar.");
        break;
    default:
        Console.WriteLine("Nota inválida.");
        break;
}

O que rola aqui?

• Se grade for 'A', 'B' ou 'C', executa o primeiro bloco: "Aprovado!".
• Se for 'D' ou 'E' — o segundo bloco.
• Se for outro — default.

6. O que pode e o que não pode no switch clássico

Pode:

• Usar literais (constantes) nos case, tipo: case 1:, case 'A':, case "stop":.
• Comparar enum (enums).
• Pular o default, mas normalmente ele é útil.

Não pode:

• Usar variáveis nos case (só constantes).
• Comparar por intervalos (case >= 5:, case x > 10: — não rola!).
• Usar double, float e outros valores de ponto flutuante — só inteiro, string, char, enum.
• Colocar vários valores separados por vírgula em um case (case 1, 2: não pode; faz vários case seguidos).

7. Particularidades e erros comuns

Na vida real, o switch é muito usado pra menus, status, comandos, códigos de erro e mil outras coisas. Mas, como qualquer ferramenta, tem suas pegadinhas.

Erros comuns:

• Esquecer o break (já falei disso).
• Tipo errado na expressão do switch (tipo tentar usar double).
• Maiúscula/minúscula diferente nas strings (case "Start": não bate com "start") — string compara levando em conta o case!
• Valor não tratado (esqueceu o default, o usuário digitou algo nada a ver).

Pegadinha com switch aninhado
Até dá pra ver código assim por aí, mas geralmente fica difícil de ler. Se você se pegar colocando um switch dentro de outro, talvez seja hora de separar seu código em um método ou até usar OOP/enum/array.