Partager via

switch expression - modèles correspondants expressions à l’aide du switch mot clé

Vous utilisez l’expression switch pour évaluer une seule expression à 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’instruction switch qui prend en charge switchla sémantique -like dans un contexte d’instruction, consultez la switch section d’instruction de l’article Instructions Selection .

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

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

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

  • Modèle constant : pour gérer les valeurs définies de l’énumération Direction .
  • Modèle d’abandon : pour gérer une 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 switch expression est la valeur de l’expression du premier switch bras d’expression dont le modèle correspond à truel’expression d’entrée et dont la protection de casse, le cas échéant, prend la valeur . Les switch bras d’expression sont évalués dans l’ordre de texte.

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

Gardes de cas

Un modèle peut ne pas être suffisamment expressif pour spécifier la condition pour l’évaluation de l’expression d’un bras. Dans ce cas, vous pouvez utiliser un garde de cas. Un garde-cas est une autre condition qui doit être satisfaite avec un modèle mis en correspondance. Un garde de casse doit être une expression booléenne. Vous spécifiez une protection de casse après le when mot clé qui suit un modèle, comme l’illustre 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 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 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 switch expression 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 / Astuce

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