expression Switch (référence C#)

À compter de C# 8,0, vous utilisez l' switch expression pour évaluer une expression unique à partir d’une liste d’expressions candidates en fonction d’une correspondance de modèle avec une expression d’entrée. Pour plus d’informations sur l' switch instruction qui prend en charge la switch sémantique like dans un contexte d’instruction, consultez la section switch instruction de l’article instructions de sélection .

L’exemple suivant illustre une switch expression, qui convertit les valeurs d’un enum représentant des directions visuelles d’une carte en ligne en 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 switch expression :

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

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

  • Modèle de constante: pour gérer les valeurs définies de l' Direction énumération.
  • Modèle d’abandon: pour gérer toute valeur entière qui n’a pas le membre correspondant de l' Direction énumération (par exemple, (Direction)10 ). L’expression est switch donc exhaustive.

Important

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

Le résultat d’une switch expression 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 la casse, le cas échéant, prend la valeur true . Les switch branches d’expression sont évaluées dans l’ordre de texte.

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

Protecteurs de cas

Un modèle peut ne pas être suffisamment expressif pour spécifier la condition d’évaluation de l’expression d’un ARM. Dans ce cas, vous pouvez utiliser une protection de cas. Il s’agit d’une condition supplémentaire qui doit être satisfaite avec un modèle correspondant. Une protection de cas doit être une expression booléenne. Vous spécifiez un garde de cas après le when mot clé 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 varimbriqués.

Expressions de commutateur non exhaustives

Si aucun des modèles d’une switch expression ne correspond à une valeur d’entrée, le runtime lève une exception. Dans .NET Core 3,0 et versions ultérieures, l’exception est System.Runtime.CompilerServices.SwitchExpressionException . dans .NET Framework, l’exception est un InvalidOperationException . Le compilateur génère un avertissement si une switch expression ne gère pas toutes les valeurs d’entrée possibles.

Conseil

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

spécification du langage C#

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

Voir aussi