Switch in C#: case, break, default e più casi insieme

Un'istruzione switch confronta un valore con un elenco di etichette case costanti ed esegue la sezione che corrisponde. In C# ogni sezione deve terminare con break (o un'altra istruzione che ne esce), quindi un case non può mai proseguire silenziosamente nel successivo.

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

Il valore tra parentesi viene valutato una volta e confrontato con ogni etichetta. default viene eseguito quando non corrisponde nulla; è facoltativo e può comparire in qualsiasi punto dell'elenco, anche se di solito va per ultimo. Se non c'è corrispondenza e manca default, l'intero switch non fa nulla.

Ogni sezione ha bisogno di un break

In C, C++, Java e JavaScript, dimenticare break fa scivolare l'esecuzione nel case successivo. C# trasforma quell'errore in un errore di compilazione:

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

La regola è che la fine dell'elenco di istruzioni di una sezione non deve essere raggiungibile. break è il modo abituale per rispettarla, ma funziona qualsiasi cosa che esca dalla sezione:

• return esce dall'intero metodo, spesso la forma più pulita dentro un piccolo metodo di supporto.
• throw lancia un'eccezione per un valore che non dovrebbe mai presentarsi.
• continue salta all'iterazione successiva quando lo switch si trova dentro un ciclo.
• goto case e goto default saltano di proposito a un'altra sezione.

L'ultima sezione non fa eccezione. Un default: in fondo senza break fallisce con CS8070, Control cannot fall out of switch from final case label ('default:').

Più valori in un solo case

Le etichette senza istruzioni tra di loro condividono la sezione sottostante. È l'unico tipo di passaggio da un case all'altro che C# consente, perché un'etichetta vuota non può nascondere codice:

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

Qui ogni sezione termina con return, quindi non serve break (un break dopo un return sarebbe codice irraggiungibile). Due etichette con lo stesso valore sono un errore, CS0152 The switch statement contains multiple cases with the label value '1', e ogni etichetta deve essere una costante nota in fase di compilazione: una variabile in un case fallisce con "a constant value is expected".

Switch su una stringa

Dopo gli interi, le stringhe sono il valore più comune in uno switch. Il confronto è ordinale e distingue maiuscole e minuscole, quindi normalizza l'input prima dello 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)

Senza ToLowerInvariant, "STOP" finirebbe in default. Fare lo switch su un valore null è lecito: non corrisponde a nessuna costante stringa e finisce in default, quindi lo switch in sé non lancia mai eccezioni.

Switch su un enum

Gli enum sono ciò per cui switch è stato pensato: un insieme chiuso di valori con 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");
        }
    }
}

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

Il compilatore non verifica che un'istruzione switch copra ogni membro dell'enum, e una variabile enum può contenere qualsiasi intero del suo tipo sottostante ((OrderStatus)42 è lecito). Il default che lancia un'eccezione trasforma un case dimenticato in un errore immediato ed evidente invece che in un'operazione nulla e silenziosa.

goto case e goto default

Quando un case deve davvero continuare in un altro, C# ti obbliga a scrivere il 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");
    }
}

Output:

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

goto case accetta una costante che deve corrispondere a una delle etichette dello stesso switch. Nel codice reale è raro: il comportamento condiviso di solito è più chiaro come metodo chiamato da più case. Resta comunque la risposta a "come faccio il fall through in C#".

Variabili dentro i case

L'intero blocco switch è un unico ambito, quindi due case non possono dichiarare una variabile con lo stesso 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;
}

Racchiudi il corpo di ogni sezione tra graffe per dargli un ambito proprio: case "square": { int area = side * side; ... break; }.

break dentro un ciclo

break in un case esce dallo switch, non dal ciclo che lo contiene. continue fa l'opposto: uno switch non è un ciclo, quindi continue passa all'iterazione successiva del ciclo.

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

Il ciclo è andato avanti dopo "end" e ha aggiunto 99. Per fermare il ciclo dall'interno di uno switch, imposta un flag e controllalo dopo lo switch, oppure sposta il ciclo in un metodo e usa return. La pagina su break e continue confronta le opzioni.

Etichette case con pattern e when

Da C# 7.0, un'etichetta case può essere un pattern invece di una costante: può verificare il tipo del valore e aggiungere una condizione when. Questa forma è comune nel codice 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}";
    }
}

Con i pattern l'ordine conta: vince il primo case che corrisponde, e il compilatore segnala un errore quando un case non può mai essere raggiunto perché uno precedente lo copre già (mettere case int n: sopra case int n when n < 0: fallisce). La clausola when funziona anche sui case costanti: case 0 when isAdmin:. C# 9 ha aggiunto i pattern relazionali e logici, quindi un case può essere case >= 90: o case 'a' or 'e' or 'i':.

In C# 7 senza pattern, lo stesso smistamento per tipo è una catena di if con il pattern di 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));
        }
    }
}

Output:

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

Quando ogni ramo di uno switch si limita a calcolare un valore, la switch expression è ancora più breve: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. La pagina sulla switch expression ne copre la sintassi, i pattern e le regole di esaustività.

Su cosa puoi fare lo switch