switch case em C#: case, break, default e vários casos

Uma instrução switch compara um valor com uma lista de rótulos case constantes e executa a seção correspondente. Em C#, toda seção precisa terminar com break (ou outra instrução que saia dela), então um case nunca continua no próximo sem aviso.

using System;

class Program
{
    static void Describe(int statusCode)
    {
        switch (statusCode)
        {
            case 200:
                Console.WriteLine($"{statusCode}: OK");
                break;
            case 301:
            case 302:
                Console.WriteLine($"{statusCode}: redirect");
                break;
            case 404:
                Console.WriteLine($"{statusCode}: not found");
                break;
            default:
                Console.WriteLine($"{statusCode}: unhandled status");
                break;
        }
    }

    static void Main()
    {
        int[] codes = { 200, 302, 404, 500 };
        foreach (int code in codes)
        {
            Describe(code);
        }
    }
}

Saída:

200: OK
302: redirect
404: not found
500: unhandled status

O valor entre parênteses é avaliado uma vez e comparado com cada rótulo. default executa quando nada corresponde; ele é opcional e pode aparecer em qualquer lugar da lista, embora normalmente venha por último. Se não houver correspondência nem default, o switch inteiro não faz nada.

Toda seção precisa de break

Em C, C++, Java e JavaScript, esquecer o break faz a execução escorregar para o próximo case. C# transforma esse erro em erro de compilação:

switch (level)
{
    case 1:
        Console.WriteLine("read");
        // error CS0163: Control cannot fall through from one case label ('case 1:') to another
    case 2:
        Console.WriteLine("write");
        break;
}

A regra é que o fim da lista de instruções de uma seção não pode ser alcançável. break é a forma usual de cumprir isso, mas qualquer coisa que saia da seção funciona:

• return sai do método inteiro, o que muitas vezes é a forma mais limpa dentro de um método auxiliar pequeno.
• throw lança uma exceção para um valor que nunca deveria aparecer.
• continue pula para a próxima iteração quando o switch está dentro de um laço.
• goto case e goto default pulam para outra seção de propósito.

A última seção não é exceção. Um default: no final sem break falha com CS8070, Control cannot fall out of switch from final case label ('default:').

Vários valores em um case

Rótulos sem instruções entre eles compartilham a seção abaixo. Esse é o único tipo de fall through que C# permite, porque um rótulo vazio não pode esconder código:

using System;

class Program
{
    static string Kind(char c)
    {
        switch (char.ToLowerInvariant(c))
        {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                return "vowel";
            case ' ':
            case '\t':
                return "space";
            default:
                return char.IsDigit(c) ? "digit" : "consonant or symbol";
        }
    }

    static void Main()
    {
        foreach (char c in "Ok 7")
        {
            Console.WriteLine($"'{c}' is a {Kind(c)}");
        }
    }
}

Saída:

'O' is a vowel
'k' is a consonant or symbol
' ' is a space
'7' is a digit

Cada seção aqui termina com return, então nenhum break é necessário (um break depois de um return seria código inalcançável). Dois rótulos com o mesmo valor são um erro, CS0152 The switch statement contains multiple cases with the label value '1', e todo rótulo precisa ser uma constante de tempo de compilação: uma variável em um case falha com "a constant value is expected".

switch com string

Strings são o valor de switch mais comum depois dos inteiros. A comparação é ordinal e diferencia maiúsculas de minúsculas, então normalize a entrada antes do switch:

using System;

class Program
{
    static void Main()
    {
        string[] commands = { "start", "STOP", "  Status ", "restart", null };

        foreach (string raw in commands)
        {
            string command = raw == null ? null : raw.Trim().ToLowerInvariant();

            switch (command)
            {
                case "start":
                    Console.WriteLine("Starting the server");
                    break;
                case "stop":
                    Console.WriteLine("Stopping the server");
                    break;
                case "status":
                    Console.WriteLine("Server is running");
                    break;
                default:
                    Console.WriteLine($"Unknown command: {command ?? "(none)"}");
                    break;
            }
        }
    }
}

Saída:

Starting the server
Stopping the server
Server is running
Unknown command: restart
Unknown command: (none)

Sem ToLowerInvariant, "STOP" chegaria ao default. Um valor null é permitido no switch: ele não corresponde a nenhuma constante string e cai no default, então o switch em si nunca lança exceção.

switch com enum

Enums são exatamente o caso para o qual o switch foi feito: um conjunto fechado de valores com nome.

using System;

enum OrderStatus { Pending, Paid, Shipped, Delivered, Cancelled }

class Program
{
    static string Next(OrderStatus status)
    {
        switch (status)
        {
            case OrderStatus.Pending:
                return "wait for payment";
            case OrderStatus.Paid:
                return "pack and ship";
            case OrderStatus.Shipped:
                return "track the parcel";
            case OrderStatus.Delivered:
            case OrderStatus.Cancelled:
                return "nothing, order is closed";
            default:
                throw new ArgumentOutOfRangeException(nameof(status));
        }
    }

    static void Main()
    {
        foreach (OrderStatus s in Enum.GetValues(typeof(OrderStatus)))
        {
            Console.WriteLine($"{s}: {Next(s)}");
        }
        try
        {
            Next((OrderStatus)42);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine($"{e.GetType().Name} for value 42");
        }
    }
}

Saída:

Pending: wait for payment
Paid: pack and ship
Shipped: track the parcel
Delivered: nothing, order is closed
Cancelled: nothing, order is closed
ArgumentOutOfRangeException for value 42

O compilador não verifica se uma instrução switch cobre todos os membros do enum, e uma variável enum pode guardar qualquer inteiro do tipo subjacente ((OrderStatus)42 é válido). O default que lança uma exceção transforma um case esquecido em uma falha imediata e óbvia, em vez de algo que silenciosamente não faz nada.

goto case e goto default

Quando um case realmente deve continuar em outro, C# obriga você a escrever o salto:

using System;

class Program
{
    static void Grant(string role)
    {
        Console.WriteLine($"{role}:");
        switch (role)
        {
            case "admin":
                Console.WriteLine("  manage users");
                goto case "editor";
            case "editor":
                Console.WriteLine("  edit posts");
                goto default;
            default:
                Console.WriteLine("  read posts");
                break;
        }
    }

    static void Main()
    {
        Grant("admin");
        Grant("editor");
        Grant("guest");
    }
}

Saída:

admin:
  manage users
  edit posts
  read posts
editor:
  edit posts
  read posts
guest:
  read posts

goto case recebe uma constante que precisa corresponder a um dos rótulos do mesmo switch. É raro em código real: comportamento compartilhado costuma ficar mais claro como um método chamado por vários cases. Ainda assim, é a resposta para "como fazer fall through em C#".

Variáveis dentro dos cases

O bloco switch inteiro é um único escopo, então dois cases não podem declarar uma variável com o mesmo nome:

switch (shape)
{
    case "square":
        int area = side * side;
        break;
    case "rectangle":
        int area = width * height;   // error CS0128: A local variable or function named 'area' is already defined in this scope
        break;
}

Envolva o corpo de cada seção em chaves para dar a ela um escopo próprio: case "square": { int area = side * side; ... break; }.

break dentro de um laço

break em um case sai do switch, não do laço em volta. continue faz o contrário: um switch não é um laço, então continue vai para a próxima iteração do laço.

using System;

class Program
{
    static void Main()
    {
        string[] lines = { "10", "# comment", "25", "end", "99" };
        int total = 0;

        foreach (string line in lines)
        {
            switch (line)
            {
                case "end":
                    Console.WriteLine("end marker found");
                    break;              // leaves the switch only
                default:
                    if (line.StartsWith("#"))
                        continue;       // skips to the next line
                    total += int.Parse(line);
                    break;
            }
        }

        Console.WriteLine($"Total: {total}");
    }
}

Saída:

end marker found
Total: 134

O laço continuou depois de "end" e somou 99. Para parar o laço de dentro de um switch, defina uma flag e teste-a depois do switch, ou mova o laço para um método e use return. A página de break e continue compara as opções.

Rótulos case com padrões e when

Desde o C# 7.0, um rótulo case pode ser um padrão em vez de uma constante: ele pode testar o tipo do valor e adicionar uma condição when. Essa forma é comum em código C# moderno:

static string Describe(object value)
{
    switch (value)
    {
        case null:
            return "nothing";
        case int n when n < 0:
            return $"negative int {n}";
        case int n:
            return $"int {n}";
        case string s when s.Length == 0:
            return "empty string";
        case string s:
            return $"string \"{s}\"";
        default:
            return $"other: {value.GetType().Name}";
    }
}

Com padrões, a ordem importa: o primeiro case que corresponde vence, e o compilador reporta um erro quando um case nunca pode ser alcançado porque um anterior já o cobre (colocar case int n: acima de case int n when n < 0: falha). A cláusula when também funciona em cases constantes: case 0 when isAdmin:. O C# 9 adicionou padrões relacionais e lógicos, então um case pode ser case >= 90: ou case 'a' or 'e' or 'i':.

No C# 7 sem padrões, o mesmo despacho por tipo é uma cadeia de if com o padrão de tipo is:

using System;

class Program
{
    static string Describe(object value)
    {
        if (value == null) return "nothing";
        if (value is int n) return n < 0 ? $"negative int {n}" : $"int {n}";
        if (value is string s) return s.Length == 0 ? "empty string" : $"string \"{s}\"";
        return $"other: {value.GetType().Name}";
    }

    static void Main()
    {
        object[] values = { -3, 12, "", "hi", 2.5m, null };
        foreach (object v in values)
        {
            Console.WriteLine(Describe(v));
        }
    }
}

Saída:

negative int -3
int 12
empty string
string "hi"
other: Decimal
nothing

Quando cada ramo de um switch só calcula um valor, a expressão switch é ainda mais curta: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. A página da expressão switch cobre a sintaxe, os padrões e as regras de exaustividade.

Com o que dá para fazer switch