Câu lệnh switch trong C#: case, break, default và nhiều case

Câu lệnh switch so sánh một giá trị với danh sách các nhãn case hằng số và chạy phần khớp với giá trị đó. Trong C#, mọi phần đều phải kết thúc bằng break (hoặc một câu lệnh khác giúp thoát khỏi phần đó), nên một case không bao giờ có thể lặng lẽ chạy sang case kế tiếp.

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

Đầu ra:

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

Giá trị trong ngoặc được tính một lần rồi so sánh với từng nhãn. default chạy khi không có gì khớp; nó không bắt buộc, và có thể đặt ở bất kỳ đâu trong danh sách, dù thường được đặt cuối cùng. Nếu không có gì khớp và không có default, cả câu lệnh switch không làm gì.

Mỗi phần đều cần break

Trong C, C++, Java và JavaScript, quên break khiến chương trình trượt xuống case tiếp theo. C# biến lỗi đó thành lỗi biên dịch:

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

Quy tắc là điểm cuối danh sách câu lệnh của một phần không được phép chạm tới. break là cách thông dụng để thỏa mãn quy tắc này, nhưng bất cứ thứ gì thoát khỏi phần đó đều được:

• return thoát khỏi toàn bộ phương thức, thường là cách gọn nhất trong một hàm hỗ trợ nhỏ.
• throw ném ngoại lệ cho một giá trị lẽ ra không bao giờ xuất hiện.
• continue nhảy sang lần lặp tiếp theo khi switch nằm trong một vòng lặp.
• goto case và goto default cố ý nhảy sang một phần khác.

Phần cuối cùng cũng không được miễn. Một default: ở cuối mà không có break sẽ lỗi CS8070, Control cannot fall out of switch from final case label ('default:').

Nhiều giá trị trong một case

Các nhãn không có câu lệnh nào xen giữa sẽ dùng chung phần bên dưới. Đây là kiểu fall through duy nhất mà C# cho phép, vì một nhãn rỗng không thể giấu code nào:

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

Đầu ra:

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

Mỗi phần ở đây kết thúc bằng return, nên không cần break (một break sau return sẽ là code không thể chạm tới). Hai nhãn cùng giá trị là lỗi, CS0152 The switch statement contains multiple cases with the label value '1', và mọi nhãn phải là hằng số lúc biên dịch: đặt một biến trong case sẽ lỗi "a constant value is expected".

Switch trên chuỗi

Sau số nguyên, chuỗi là giá trị được switch nhiều nhất. Phép so sánh là ordinal và phân biệt hoa thường, nên hãy chuẩn hóa đầu vào trước khi 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;
            }
        }
    }
}

Đầu ra:

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

Nếu không có ToLowerInvariant, "STOP" sẽ rơi vào default. Switch trên giá trị null là hợp lệ: nó không khớp hằng số chuỗi nào và rơi vào default, nên bản thân switch không bao giờ ném ngoại lệ.

Switch trên enum

Enum chính là thứ mà switch được tạo ra để xử lý: một tập đóng các giá trị có tên.

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

Đầu ra:

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

Trình biên dịch không kiểm tra xem câu lệnh switch đã bao phủ mọi thành viên enum hay chưa, và một biến enum có thể chứa bất kỳ số nguyên nào của kiểu nền ((OrderStatus)42 là hợp lệ). Nhánh default ném ngoại lệ biến một case bị bỏ quên thành lỗi xuất hiện ngay và dễ thấy, thay vì lặng lẽ không làm gì.

goto case và goto default

Khi một case thật sự nên chạy tiếp sang case khác, C# buộc bạn viết rõ lệnh nhảy:

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

Đầu ra:

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

goto case nhận một hằng số phải khớp với một trong các nhãn của cùng câu lệnh switch. Cách này hiếm gặp trong code thực tế: hành vi dùng chung thường rõ ràng hơn khi đặt trong một phương thức mà nhiều case cùng gọi. Dù vậy, đây vẫn là câu trả lời cho câu hỏi "làm sao fall through trong C#".

Biến bên trong case

Toàn bộ khối switch là một phạm vi, nên hai case không thể khai báo biến cùng tên:

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

Bọc phần thân của mỗi case trong dấu ngoặc nhọn để nó có phạm vi riêng: case "square": { int area = side * side; ... break; }.

break bên trong vòng lặp

break trong một case thoát khỏi switch, không phải vòng lặp bao quanh. continue thì ngược lại: switch không phải vòng lặp, nên continue đi tới lần lặp tiếp theo của vòng lặp.

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

Đầu ra:

end marker found
Total: 134

Vòng lặp vẫn tiếp tục sau "end" và cộng thêm 99. Để dừng vòng lặp từ bên trong switch, hãy đặt một cờ rồi kiểm tra nó sau switch, hoặc chuyển vòng lặp vào một phương thức và dùng return. Trang về break và continue so sánh các lựa chọn này.

Nhãn case dạng pattern và when

Từ C# 7.0, một nhãn case có thể là một pattern thay vì hằng số: nó có thể kiểm tra kiểu của giá trị và thêm điều kiện when. Dạng này phổ biến trong code C# hiện đại:

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

Với pattern, thứ tự rất quan trọng: case khớp đầu tiên sẽ thắng, và trình biên dịch báo lỗi khi một case không bao giờ được tới vì case trước đã bao phủ nó (đặt case int n: trên case int n when n < 0: sẽ lỗi). Mệnh đề when cũng dùng được với case hằng số: case 0 when isAdmin:. C# 9 bổ sung pattern so sánh và pattern logic, nên một case có thể viết case >= 90: hoặc case 'a' or 'e' or 'i':.

Trên C# 7 không dùng pattern, cùng phép phân loại theo kiểu đó là một chuỗi if với type pattern 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));
        }
    }
}

Đầu ra:

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

Khi mọi nhánh của switch chỉ tính ra một giá trị, switch expression còn ngắn hơn nữa: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. Trang về switch expression trình bày cú pháp, pattern và quy tắc về tính đầy đủ của nó.

Có thể switch trên những gì