C# Academy · Aula

Expressões switch

switch concisos que retornam valores.

Expressões switch é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 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.

O que é uma expressão de seleção

Uma expressão de seleção avalia uma entrada em relação a uma série de padrões e retorna um valor. Ao contrário da instrução de seleção clássica, ela é uma expressão, portanto produz um resultado que pode ser atribuído ou retornado.

Ela usa a palavra-chave switch depois do valor, com braços escritos como pattern => result. Isso torna a lógica de ramificação compacta e funcional.

int code = 2;
string name = code switch
{
    1 => "One",
    2 => "Two",
    _ => "Other"
};
System.Console.WriteLine(name);

Instrução versus expressão

A antiga instrução switch usa rótulos case e break. A nova expressão switch elimina completamente essas palavras-chave.

Os braços são separados por vírgulas, toda a construção termina com ponto e vírgula, e cada braço produz um valor em vez de executar blocos de continuação automática. Isso elimina uma categoria inteira de erros causados por esquecer break.

// Statement style
switch (code) { case 1: result = "One"; break; }

// Expression style
result = code switch { 1 => "One", _ => "?" };

O braço de descarte

O sublinhado _ é o padrão de descarte. Ele corresponde a qualquer coisa e funciona como o caso padrão.

As expressões de seleção devem ser exaustivas: se nenhum braço corresponder em tempo de execução, uma SwitchExpressionException será lançada. Adicionar um braço _ garante uma correspondência para toda entrada possível.

using System;

class Program {
    static void Main() {
        int n = 7;
        string size = n switch {
            < 5 => "small",
            _ => "big"
        };
        Console.WriteLine(size);
    }
}

Padrões constantes

O braço mais simples usa um padrão constante: um valor literal contra o qual a entrada é comparada por igualdade.

As constantes podem ser números, cadeias de caracteres, caracteres, membros de enumeração ou constantes nomeadas. Elas são avaliadas de cima para baixo; por isso, coloque primeiro os braços mais específicos ou mais comuns.

char grade = 'B';
string label = grade switch
{
    'A' => "Excellent",
    'B' => "Good",
    'C' => "Fair",
    _   => "Needs work"
};
System.Console.WriteLine(label);

Retornar de um método

As expressões de seleção são especialmente úteis dentro de métodos. Como toda a construção é uma expressão, pode retorná-la diretamente, muitas vezes como um método cujo corpo é uma expressão de uma única linha.

Isso mantém a lógica de mapeamento legível e centralizada, em vez de espalhar cadeias de if/else if pelo corpo.

using System;

class Program {
    static string Day(int d) => d switch {
        0 => "Sun", 6 => "Sat", _ => "Weekday"
    };
    static void Main() => Console.WriteLine(Day(6));
}

Seleção com enumerações

As enumerações combinam naturalmente com expressões de seleção. Cada braço nomeia um membro da enumeração, e o compilador pode avisar quando falta um caso se omitir o braço de descarte.

Ainda assim, é recomendável manter um braço _ para que valores futuros da enumeração não façam o aplicativo falhar em tempo de execução.

using System;

enum Light { Red, Yellow, Green }

class Program {
    static void Main() {
        Light l = Light.Green;
        string action = l switch {
            Light.Red => "Stop",
            Light.Yellow => "Slow",
            Light.Green => "Go",
            _ => "?"
        };
        Console.WriteLine(action);
    }
}

Cláusulas de guarda com quando

Uma guarda when adiciona uma condição booleana a um braço. O braço só corresponde quando o padrão e a guarda são verdadeiros.

Isso permite refinar as correspondências com uma lógica arbitrária que um padrão sozinho não consegue expressar, como verificações de intervalo combinadas com outras variáveis.

int temp = 30;
string weather = temp switch
{
    int t when t < 0  => "Freezing",
    int t when t < 20 => "Cool",
    _                 => "Warm"
};
System.Console.WriteLine(weather);

Order é importante

Os braços são testados na ordem em que aparecem no código. O primeiro braço correspondente vence, portanto os padrões mais específicos devem vir antes dos mais abrangentes.

Se um braço geral preceder um específico, o compilador informará que o braço posterior nunca pode ser alcançado. Leia os braços de cima para baixo, como um funil que vai do estreito ao amplo.

int score = 95;
string tier = score switch
{
    >= 90 => "Gold",
    >= 70 => "Silver",
    _     => "Bronze"
};
System.Console.WriteLine(tier);

Exaustividade e exceções

Se nem toda entrada estiver coberta e nenhum braço corresponder, o ambiente de execução lançará System.Runtime.CompilerServices.SwitchExpressionException.

O compilador emite o aviso CS8509 quando não consegue provar a exaustividade. Leve esse aviso a sério: adicione um braço de descarte ou cubra os valores ausentes para manter a expressão total.

using System;

class Program {
    static void Main() {
        try {
            int x = 5;
            string s = x switch { 1 => "a", 2 => "b" };
            Console.WriteLine(s);
        } catch (Exception e) {
            Console.WriteLine(e.GetType().Name);
        }
    }
}

Combinar várias entradas

Para selecionar com base em mais de um valor, coloque-os em uma tupla. Os braços passam a corresponder a padrões de tupla, comparando cada posição.

Isso é ideal para máquinas de estados ou tabelas de decisão em que o resultado depende de um par de fatores. Exploraremos os padrões de tupla em profundidade em uma lição posterior.

bool isWeekend = true; bool isRaining = false;
string plan = (isWeekend, isRaining) switch
{
    (true, false) => "Go hiking",
    (true, true)  => "Watch a movie",
    _             => "Work"
};
System.Console.WriteLine(plan);

Corpos de expressão legíveis

As expressões de seleção combinam bem com LINQ e membros cujo corpo é uma expressão, produzindo fluxos concisos.

Como cada braço retorna um valor, pode usar uma expressão de seleção diretamente dentro de uma projeção Select ou como argumento de um método, evitando variáveis temporárias.

using System;
using System.Linq;

class Program {
    static void Main() {
        var nums = new[] { 1, 2, 3 };
        var labels = nums.Select(n => n switch {
            1 => "one", 2 => "two", _ => "many"
        });
        Console.WriteLine(string.Join(",", labels));
    }
}

Verificação rápida

Teste sua compreensão sobre expressões de seleção.

Recapitulação

As expressões de seleção retornam um valor usando input switch { pattern => result, ... }, com braços separados por vírgulas.

Use _ para o padrão, when para as guardas e lembre-se de que os braços são testados de cima para baixo. Mantenha-os exaustivos para evitar exceções em tempo de execução. Em seguida, exploraremos os padrões de tipo e de propriedade.

Perguntas Frequentes

A aula “Expressões switch” é grátis?

Sim — o texto completo de “Expressões switch” é 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 “Expressões switch”?

switch concisos que retornam valores. 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 1 de 4.

Quanto tempo leva a aula “Expressões switch”?

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