Pernyataan switch di C#: case, break, default dan Banyak Case

Pernyataan switch membandingkan satu nilai dengan daftar label case berupa konstanta, lalu menjalankan bagian yang cocok. Di C#, setiap bagian harus diakhiri break (atau pernyataan lain yang keluar dari bagian itu), jadi satu case tidak pernah bisa diam-diam berlanjut ke case berikutnya.

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

Output:

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

Nilai di dalam tanda kurung dievaluasi sekali, lalu dibandingkan dengan setiap label. default dijalankan jika tidak ada yang cocok; bagian ini bersifat opsional dan boleh muncul di mana saja dalam daftar, meskipun biasanya ditaruh paling akhir. Jika tidak ada yang cocok dan tidak ada default, seluruh switch tidak melakukan apa-apa.

Setiap bagian butuh break

Di C, C++, Java, dan JavaScript, lupa menulis break membuat eksekusi meluncur ke case berikutnya. C# mengubah kesalahan itu menjadi error kompilasi:

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

Aturannya, akhir daftar pernyataan sebuah bagian tidak boleh bisa dicapai. break adalah cara biasa untuk memenuhinya, tetapi apa pun yang keluar dari bagian itu juga berfungsi:

• return keluar dari seluruh method, dan sering menjadi bentuk paling rapi di dalam helper kecil.
• throw melempar exception untuk nilai yang seharusnya tidak pernah muncul.
• continue melompat ke iterasi berikutnya jika switch berada di dalam perulangan.
• goto case dan goto default sengaja melompat ke bagian lain.

Bagian terakhir tidak dikecualikan. default: di paling bawah tanpa break gagal dengan CS8070, Control cannot fall out of switch from final case label ('default:').

Beberapa nilai dalam satu case

Label yang tidak punya pernyataan di antaranya berbagi bagian di bawahnya. Inilah satu-satunya jenis fall through yang diizinkan C#, karena label kosong tidak bisa menyembunyikan kode apa pun:

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

Output:

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

Setiap bagian di sini diakhiri return, jadi tidak perlu break (break setelah return akan menjadi kode yang tidak bisa dicapai). Dua label dengan nilai yang sama adalah error, CS0152 The switch statement contains multiple cases with the label value '1', dan setiap label harus berupa konstanta saat kompilasi: variabel di sebuah case gagal dengan pesan "a constant value is expected".

Switch pada string

String adalah nilai switch yang paling umum setelah bilangan bulat. Perbandingannya ordinal dan peka huruf besar kecil, jadi normalisasi input-nya sebelum melakukan 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;
            }
        }
    }
}

Output:

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

Tanpa ToLowerInvariant, "STOP" akan sampai ke default. Nilai null sah dipakai untuk switch: nilai itu tidak cocok dengan konstanta string mana pun dan jatuh ke default, jadi switch-nya sendiri tidak pernah melempar exception.

Switch pada enum

Enum adalah alasan switch dibuat: kumpulan nilai bernama yang tertutup.

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

Output:

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

Compiler tidak memeriksa apakah pernyataan switch mencakup setiap member enum, dan variabel enum bisa berisi bilangan bulat apa pun dari tipe dasarnya ((OrderStatus)42 itu sah). default yang melempar exception mengubah case yang terlupa menjadi kegagalan yang langsung dan jelas, bukan sesuatu yang diam-diam tidak melakukan apa-apa.

goto case dan goto default

Jika satu case memang harus berlanjut ke case lain, C# membuatmu menuliskan lompatannya:

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

Output:

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

goto case menerima sebuah konstanta yang harus cocok dengan salah satu label di switch yang sama. Ini jarang dipakai di kode sungguhan: perilaku bersama biasanya lebih jelas jika dijadikan method yang dipanggil beberapa case. Tetapi inilah jawaban untuk "bagaimana cara melakukan fall through di C#".

Variabel di dalam case

Seluruh blok switch adalah satu cakupan, jadi dua case tidak bisa mendeklarasikan variabel dengan nama yang sama:

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

Bungkus body setiap bagian dengan kurung kurawal agar punya cakupannya sendiri: case "square": { int area = side * side; ... break; }.

break di dalam perulangan

break di sebuah case keluar dari switch, bukan dari perulangan di sekitarnya. continue melakukan kebalikannya: switch bukan perulangan, jadi continue menuju iterasi berikutnya dari perulangan itu.

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

Output:

end marker found
Total: 134

Perulangannya tetap berjalan setelah "end" dan menambahkan 99. Untuk menghentikan perulangan dari dalam switch, isi sebuah flag lalu periksa setelah switch, atau pindahkan perulangan ke sebuah method lalu return. Halaman break dan continue membandingkan pilihan-pilihannya.

Label case berpola dan when

Sejak C# 7.0, label case bisa berupa pola, bukan hanya konstanta: label itu bisa menguji tipe nilainya dan menambahkan kondisi when. Bentuk ini umum di kode C# modern:

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

Dengan pola, urutan itu penting: case pertama yang cocok yang menang, dan compiler melaporkan error jika sebuah case tidak akan pernah tercapai karena case sebelumnya sudah mencakupnya (menaruh case int n: di atas case int n when n < 0: akan gagal). Klausa when juga bisa dipakai pada case konstanta: case 0 when isAdmin:. C# 9 menambahkan pola relasional dan logika, jadi sebuah case bisa ditulis case >= 90: atau case 'a' or 'e' or 'i':.

Di C# 7 tanpa pola, pemilihan berdasarkan tipe yang sama ditulis sebagai rangkaian if dengan pola tipe 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));
        }
    }
}

Output:

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

Jika setiap cabang switch hanya menghitung sebuah nilai, ekspresi switch lebih ringkas lagi: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. Halaman ekspresi switch membahas sintaks, pola, dan aturan exhaustiveness-nya.

Nilai yang bisa dipakai untuk switch