Instrukcja switch w C#: case, break, default i wiele przypadków

Instrukcja switch porównuje jedną wartość z listą stałych etykiet case i wykonuje pasującą sekcję. W C# każda sekcja musi kończyć się break (albo inną instrukcją, która ją opuszcza), więc jeden przypadek nigdy nie przejdzie po cichu do następnego.

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);
        }
    }
}

Wynik:

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

Wartość w nawiasach jest obliczana raz i porównywana z każdą etykietą. default wykonuje się, gdy nic nie pasuje; jest opcjonalny i może stać w dowolnym miejscu listy, choć zwykle jest na końcu. Jeśli nic nie pasuje i nie ma default, cały switch nic nie robi.

Każda sekcja potrzebuje break

W C, C++, Javie i JavaScripcie zapomniane break sprawia, że wykonanie zjeżdża do następnego przypadku. C# zamienia ten błąd w błąd kompilacji:

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;
}

Zasada brzmi: koniec listy instrukcji sekcji nie może być osiągalny. Zwykle spełnia się ją przez break, ale działa wszystko, co opuszcza sekcję:

• return opuszcza całą metodę, co w małej metodzie pomocniczej jest często najschludniejszą formą.
• throw rzuca wyjątek dla wartości, która nigdy nie powinna wystąpić.
• continue przechodzi do następnej iteracji, gdy switch jest wewnątrz pętli.
• goto case i goto default celowo skaczą do innej sekcji.

Ostatnia sekcja nie jest wyjątkiem. default: na dole bez break kończy się błędem CS8070, Control cannot fall out of switch from final case label ('default:').

Kilka wartości w jednym case

Etykiety bez instrukcji między nimi współdzielą sekcję poniżej. To jedyny rodzaj przejścia, na który C# pozwala, bo pusta etykieta nie może ukryć żadnego kodu:

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)}");
        }
    }
}

Wynik:

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

Każda sekcja kończy się tu return, więc break nie jest potrzebny (break po return byłby nieosiągalnym kodem). Dwie etykiety z tą samą wartością to błąd, CS0152 The switch statement contains multiple cases with the label value '1', a każda etykieta musi być stałą znaną w czasie kompilacji: zmienna w case kończy się błędem "a constant value is expected".

Switch na stringu

Stringi to po liczbach całkowitych najczęstsza wartość w switch. Porównanie jest porządkowe i rozróżnia wielkość liter, więc przed switch znormalizuj wejście:

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;
            }
        }
    }
}

Wynik:

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

Bez ToLowerInvariant "STOP" trafiłoby do default. Switch na wartości null jest dozwolony: nie pasuje do żadnej stałej stringa i trafia do default, więc sam switch nigdy nie rzuca wyjątku.

Switch na enum

Typy wyliczeniowe to coś, do czego switch stworzono: zamknięty zbiór nazwanych wartości.

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");
        }
    }
}

Wynik:

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

Kompilator nie sprawdza, czy instrukcja switch pokrywa każdy element enum, a zmienna enum może przechowywać dowolną liczbę całkowitą typu bazowego ((OrderStatus)42 jest dozwolone). default, który rzuca wyjątek, zamienia zapomniany przypadek w natychmiastowy, oczywisty błąd zamiast cichego braku działania.

goto case i goto default

Gdy jeden przypadek naprawdę powinien przejść do innego, C# każe ci zapisać skok:

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");
    }
}

Wynik:

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

goto case przyjmuje stałą, która musi pasować do jednej z etykiet w tym samym switch. W prawdziwym kodzie jest rzadkie: wspólne zachowanie jest zwykle czytelniejsze jako metoda wywoływana przez kilka przypadków. Nadal jest to jednak odpowiedź na pytanie, jak przejść dalej w C#.

Zmienne wewnątrz case

Cały blok switch to jeden zakres, więc dwa przypadki nie mogą zadeklarować zmiennej o tej samej nazwie:

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;
}

Otocz ciało każdej sekcji nawiasami klamrowymi, żeby dać jej własny zakres: case "square": { int area = side * side; ... break; }.

break wewnątrz pętli

break w case opuszcza switch, a nie otaczającą go pętlę. continue działa odwrotnie: switch nie jest pętlą, więc continue przechodzi do następnej iteracji pętli.

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}");
    }
}

Wynik:

end marker found
Total: 134

Pętla działała dalej po "end" i dodała 99. Żeby zatrzymać pętlę z wnętrza switch, ustaw flagę i sprawdź ją po switch albo przenieś pętlę do metody i użyj return. Strona o break i continue porównuje te możliwości.

Etykiety case ze wzorcami i when

Od C# 7.0 etykieta case może być wzorcem zamiast stałej: może sprawdzać typ wartości i dodawać warunek when. Ta forma jest częsta we współczesnym kodzie C#:

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}";
    }
}

Przy wzorcach kolejność ma znaczenie: wygrywa pierwszy pasujący przypadek, a kompilator zgłasza błąd, gdy do przypadku nigdy nie da się dojść, bo wcześniejszy już go pokrywa (umieszczenie case int n: nad case int n when n < 0: kończy się błędem). Klauzula when działa też na stałych przypadkach: case 0 when isAdmin:. C# 9 dodał wzorce relacyjne i logiczne, więc case może brzmieć case >= 90: albo case 'a' or 'e' or 'i':.

W C# 7 bez wzorców to samo rozdzielanie według typu to łańcuch if ze wzorcem typu 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));
        }
    }
}

Wynik:

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

Gdy każda gałąź switch tylko oblicza wartość, wyrażenie switch jest jeszcze krótsze: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. Strona o wyrażeniu switch omawia jego składnię, wzorce i zasady pełnego pokrycia.

Na czym można robić switch