Оператор switch в C#: case, break, default и несколько значений в case

Оператор switch сравнивает одно значение со списком константных меток case и выполняет совпавший раздел. В C# каждый раздел должен заканчиваться break (или другим оператором, который из него выходит), поэтому один case никогда не может молча перейти в следующий.

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

Вывод:

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

Значение в скобках вычисляется один раз и сравнивается с каждой меткой. default выполняется, когда ничего не совпало; он необязателен и может стоять в любом месте списка, хотя обычно идёт последним. Если совпадения нет и default отсутствует, весь switch ничего не делает.

Каждому разделу нужен break

В C, C++, Java и JavaScript забытый break заставляет выполнение соскользнуть в следующий case. C# превращает эту ошибку в ошибку компиляции:

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

Правило такое: конец списка операторов раздела не должен быть достижим. Обычно это правило выполняют через break, но подходит всё, что выходит из раздела:

• return выходит из всего метода, и внутри небольшого вспомогательного метода это часто самая аккуратная форма.
• throw выбрасывает исключение для значения, которое никогда не должно встретиться.
• continue переходит к следующей итерации, когда switch находится внутри цикла.
• goto case и goto default намеренно переходят в другой раздел.

Последний раздел не исключение. default: в конце без break завершается ошибкой CS8070, Control cannot fall out of switch from final case label ('default:').

Несколько значений в одном case

Метки без операторов между ними разделяют раздел, стоящий под ними. Это единственный вид проваливания, который разрешает C#, потому что в пустой метке не может скрываться код:

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

Вывод:

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

Каждый раздел здесь заканчивается return, поэтому break не нужен (break после return был бы недостижимым кодом). Две метки с одинаковым значением это ошибка CS0152 The switch statement contains multiple cases with the label value '1', а каждая метка должна быть константой времени компиляции: переменная в case вызывает ошибку «a constant value is expected».

switch по строке

После целых чисел строки это самое частое значение в switch. Сравнение порядковое и с учётом регистра, поэтому нормализуйте входные данные перед 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;
            }
        }
    }
}

Вывод:

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

Без ToLowerInvariant значение "STOP" попало бы в default. Значение null в switch допустимо: оно не совпадает ни с одной строковой константой и уходит в default, поэтому сам switch никогда не выбрасывает исключение.

switch по перечислению

Перечисления это то, для чего switch и создавался: закрытый набор именованных значений.

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

Вывод:

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

Компилятор не проверяет, что оператор switch охватывает все члены перечисления, а переменная перечисления может хранить любое целое число базового типа ((OrderStatus)42 допустимо). default, который выбрасывает исключение, превращает забытый case в немедленную и очевидную ошибку вместо молчаливого бездействия.

goto case и goto default

Когда один case действительно должен продолжиться в другом, C# заставляет написать переход:

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

Вывод:

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

goto case принимает константу, которая должна совпадать с одной из меток того же switch. В реальном коде он редок: общее поведение обычно понятнее вынести в метод, который вызывают несколько case. Тем не менее это ответ на вопрос «как провалиться в следующий case в C#».

Переменные внутри case

Весь блок switch это одна область видимости, поэтому два case не могут объявить переменную с одинаковым именем:

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

Заключите тело каждого раздела в фигурные скобки, чтобы дать ему собственную область видимости: case "square": { int area = side * side; ... break; }.

break внутри цикла

break в case выходит из switch, а не из окружающего цикла. continue делает обратное: switch не является циклом, поэтому continue переходит к следующей итерации цикла.

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

Вывод:

end marker found
Total: 134

Цикл продолжился после "end" и добавил 99. Чтобы остановить цикл изнутри switch, установите флаг и проверьте его после switch или вынесите цикл в метод и используйте return. Варианты сравниваются на странице о break и continue.

Метки case с шаблонами и when

Начиная с C# 7.0 метка case может быть шаблоном, а не константой: она может проверять тип значения и добавлять условие when. Эта форма распространена в современном коде на 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}";
    }
}

С шаблонами порядок важен: побеждает первый совпавший case, а компилятор сообщает об ошибке, если case никогда не может быть достигнут, потому что предыдущий уже его покрывает (размещение case int n: выше case int n when n < 0: не компилируется). Условие when работает и с константными case: case 0 when isAdmin:. C# 9 добавил реляционные и логические шаблоны, поэтому case может выглядеть как case >= 90: или case 'a' or 'e' or 'i':.

В C# 7 без шаблонов та же диспетчеризация по типу записывается цепочкой if с шаблоном типа 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));
        }
    }
}

Вывод:

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

Когда каждая ветка switch только вычисляет значение, switch-выражение ещё короче: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. Его синтаксис, шаблоны и правила полноты описаны на странице о switch-выражении.

По чему можно делать switch