Instruction switch en C# : case, break, default et cas multiples

Une instruction switch compare une valeur à une liste d'étiquettes case constantes et exécute la section qui correspond. En C#, chaque section doit se terminer par break (ou une autre instruction qui la quitte), si bien qu'un cas ne peut jamais glisser silencieusement dans le suivant.

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

Sortie :

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

La valeur entre parenthèses est évaluée une fois et comparée à chaque étiquette. default s'exécute quand rien ne correspond ; il est facultatif et peut apparaître n'importe où dans la liste, même s'il se place en général à la fin. S'il n'y a ni correspondance ni default, le switch entier ne fait rien.

Chaque section a besoin d'un break

En C, C++, Java et JavaScript, oublier break fait glisser l'exécution dans le cas suivant. C# transforme cette erreur en erreur de compilation :

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 règle est que la fin de la liste d'instructions d'une section ne doit pas être atteignable. break est la façon habituelle de la respecter, mais tout ce qui quitte la section fonctionne :

• return quitte toute la méthode, ce qui est souvent la forme la plus propre dans une petite fonction.
• throw lève une exception pour une valeur qui ne devrait jamais se produire.
• continue passe à l'itération suivante quand le switch se trouve dans une boucle.
• goto case et goto default sautent délibérément vers une autre section.

La dernière section n'est pas exemptée. Un default: en bas sans break échoue avec CS8070, Control cannot fall out of switch from final case label ('default:').

Plusieurs valeurs dans un même case

Les étiquettes sans instruction entre elles partagent la section située en dessous. C'est le seul enchaînement que C# autorise, car une étiquette vide ne peut cacher aucun code :

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

Sortie :

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

Chaque section se termine ici par return, donc aucun break n'est nécessaire (un break après un return serait du code inaccessible). Deux étiquettes de même valeur sont une erreur, CS0152 The switch statement contains multiple cases with the label value '1', et chaque étiquette doit être une constante de compilation : une variable dans un case échoue avec « a constant value is expected ».

switch sur une string

Les chaînes sont la valeur de switch la plus courante après les entiers. La comparaison est ordinale et sensible à la casse, donc normalisez l'entrée avant le 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;
            }
        }
    }
}

Sortie :

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

Sans ToLowerInvariant, "STOP" atteindrait default. Faire un switch sur une valeur null est légal : elle ne correspond à aucune constante chaîne et tombe dans default, donc le switch lui-même ne lève jamais d'exception.

switch sur un enum

Les enums sont ce pour quoi switch a été conçu : un ensemble fermé de valeurs nommées.

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

Sortie :

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

Le compilateur ne vérifie pas qu'une instruction switch couvre chaque membre de l'enum, et une variable enum peut contenir n'importe quel entier de son type sous-jacent ((OrderStatus)42 est légal). Le default qui lève une exception transforme un cas oublié en échec immédiat et évident, au lieu d'une absence d'action silencieuse.

goto case et goto default

Quand un cas doit vraiment se poursuivre dans un autre, C# vous oblige à écrire le saut :

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

Sortie :

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

goto case prend une constante qui doit correspondre à l'une des étiquettes du même switch. C'est rare dans du vrai code : un comportement partagé est en général plus clair sous forme d'une méthode que plusieurs cas appellent. C'est tout de même la réponse à « comment enchaîner les cas en C# ».

Les variables dans les cases

Tout le bloc switch forme une seule portée, donc deux cas ne peuvent pas déclarer une variable du même nom :

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

Entourez le corps de chaque section d'accolades pour lui donner sa propre portée : case "square": { int area = side * side; ... break; }.

break dans une boucle

break dans un case quitte le switch, pas la boucle qui l'entoure. continue fait l'inverse : un switch n'est pas une boucle, donc continue passe à l'itération suivante de la boucle.

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

Sortie :

end marker found
Total: 134

La boucle a continué après "end" et a ajouté 99. Pour arrêter la boucle depuis un switch, positionnez un indicateur et testez-le après le switch, ou déplacez la boucle dans une méthode et utilisez return. La page sur break et continue compare les options.

Étiquettes à pattern et when

Depuis C# 7.0, une étiquette case peut être un pattern au lieu d'une constante : elle peut tester le type de la valeur et ajouter une condition when. Cette forme est courante dans le code C# moderne :

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

Avec les patterns, l'ordre compte : le premier cas qui correspond l'emporte, et le compilateur signale une erreur quand un cas ne peut jamais être atteint parce qu'un cas précédent le couvre déjà (placer case int n: au-dessus de case int n when n < 0: échoue). La clause when fonctionne aussi sur les cas constants : case 0 when isAdmin:. C# 9 a ajouté les patterns relationnels et logiques, si bien qu'un cas peut s'écrire case >= 90: ou case 'a' or 'e' or 'i':.

En C# 7 sans patterns, le même aiguillage par type est une chaîne de if avec le pattern de type 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));
        }
    }
}

Sortie :

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

Quand chaque branche d'un switch ne fait que calculer une valeur, l'expression switch est encore plus courte : var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. La page sur l'expression switch couvre sa syntaxe, ses patterns et ses règles d'exhaustivité.

Sur quoi peut-on faire un switch