Partage via

expression switch : expressions de correspondance de modèle à l’aide du mot clé switch

  • Article

Vous utilisez l’expression switch pour évaluer une seule expression à partir d’une liste d’expressions candidates basées sur une correspondance de modèle avec une expression d’entrée. Pour plus d’informations sur l’instruction switch qui prend en charge switchla sémantique -like dans un contexte d’instruction, consultez la section switchinstruction de l’article Instructions de sélection .

L’exemple suivant illustre une expression switch, qui convertit les valeurs d’un enum représentant des directions visuelles dans une carte en ligne dans les directions cardinales correspondantes :

public static class SwitchExample
{
    public enum Direction
    {
        Up,
        Down,
        Right,
        Left
    }

    public enum Orientation
    {
        North,
        South,
        East,
        West
    }

    public static Orientation ToOrientation(Direction direction) => direction switch
    {
        Direction.Up    => Orientation.North,
        Direction.Right => Orientation.East,
        Direction.Down  => Orientation.South,
        Direction.Left  => Orientation.West,
        _ => throw new ArgumentOutOfRangeException(nameof(direction), $"Not expected direction value: {direction}"),
    };

    public static void Main()
    {
        var direction = Direction.Right;
        Console.WriteLine($"Map view direction is {direction}");
        Console.WriteLine($"Cardinal orientation is {ToOrientation(direction)}");
        // Output:
        // Map view direction is Right
        // Cardinal orientation is East
    }
}

L’exemple précédent montre les éléments de base d’une expression switch :

  • Expression suivie du mot clé switch. Dans l’exemple précédent, il s’agit du paramètre de méthode direction.
  • Les switch bras d’expression, séparés par des virgules. Chaque switch bras d’expression contient un modèle, une protection de cas facultative, le jeton => et une expression.

Dans l’exemple précédent, une expression switch utilise les modèles suivants :

  • Un modèle constant : pour gérer les valeurs définies de l’énumération Direction.
  • Un modèle d’abandon : pour gérer toute valeur entière qui n’a pas le membre correspondant de l’énumération Direction (par exemple, (Direction)10). Cela rend l’expression switchexhaustive.

Important

Pour plus d’informations sur les modèles pris en charge par l’expression switch et d’autres exemples, consultez Modèles.

Le résultat d’une expression switch est la valeur de l’expression du premier switch bras d’expression dont le modèle correspond à l’expression d’entrée et dont la protection de cas, le cas échéant, prend la valeur true. Les bras d’expression switch sont évalués dans l’ordre textuel.

Le compilateur génère une erreur lorsqu’un bras d’expression inférieur switch ne peut pas être choisi, car un bras d’expression supérieur switch correspond à toutes ses valeurs.

Protections de cas

Un modèle peut ne pas être suffisamment expressif pour spécifier la condition d’évaluation de l’expression d’un bras. Dans ce cas, vous pouvez utiliser une protection de cas. Une protection contre la casse est une autre condition qui doit être satisfaite avec un modèle correspondant. Une protection de cas doit être une expression booléenne. Vous spécifiez une protection de cas après le mot clé when qui suit un modèle, comme le montre l’exemple suivant :

public readonly struct Point
{
    public Point(int x, int y) => (X, Y) = (x, y);
    
    public int X { get; }
    public int Y { get; }
}

static Point Transform(Point point) => point switch
{
    { X: 0, Y: 0 }                    => new Point(0, 0),
    { X: var x, Y: var y } when x < y => new Point(x + y, y),
    { X: var x, Y: var y } when x > y => new Point(x - y, y),
    { X: var x, Y: var y }            => new Point(2 * x, 2 * y),
};

L’exemple précédent utilise des modèles de propriété avec des modèles var imbriqués.

Expressions de commutateur non exhaustives

Si aucun des modèles d’une expression switchne correspond à une valeur d’entrée, le runtime lève une exception. Dans .NET Core 3.0 et versions ultérieures, l’exception est un System.Runtime.CompilerServices.SwitchExpressionException. Dans .NET Framework, l’exception est un InvalidOperationException. Dans la plupart des cas, le compilateur génère un avertissement si une expression switch ne gère pas toutes les valeurs d’entrée possibles. Les modèles de liste ne génèrent pas d’avertissement lorsque toutes les entrées possibles ne sont pas gérées.

Conseil

Pour garantir qu’une switch expression gère toutes les valeurs d’entrée possibles, fournissez un bras d’expression switch avec un modèle d’abandon.

spécification du langage C#

Pour plus d’informations, consultez la switch section expression de la note de proposition de fonctionnalité.

Voir aussi