Partage via

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

Utilisez l’expression switch pour évaluer une seule expression à partir d’une liste d’expressions candidates. L’évaluation est basée 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 switch section d’instruction de l’article Instructions Selection .

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

L’exemple suivant illustre une switch expression. Il convertit les valeurs d’une enum représentation 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 Ce modèle 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, utilisez 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. 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 spécification du langage C#.

Voir aussi

  • Last updated on