Compartilhar via

expressão switch - expressões de correspondência de padrão usando a switch palavra-chave

Você usa a switch expressão para avaliar uma única expressão de uma lista de expressões candidatas com base em uma correspondência de padrão com uma expressão de entrada. Para obter informações sobre a switch instrução que dá switchsuporte à semântica semelhante em um contexto de instrução, consulte a switch seção de instrução do artigo instruções Selection .

O exemplo a seguir demonstra uma switch expressão, que converte valores de uma enum direção visual representando em um mapa online para as direções cardeais correspondentes:

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

O exemplo anterior mostra os elementos básicos de uma switch expressão:

  • Uma expressão seguida pela switch palavra-chave. No exemplo anterior, é o parâmetro do direction método.
  • Os switch braços de expressão, separados por vírgulas. Cada switch braço de expressão contém um padrão, um proteção de maiúsculas de minúsculas opcional, o => token e uma expressão.

No exemplo anterior, uma switch expressão usa os seguintes padrões:

  • Um padrão constante: para lidar com os valores definidos da Direction enumeração.
  • Um padrão de descarte: para manipular qualquer valor inteiro que não tenha o membro correspondente da Direction enumeração (por exemplo, (Direction)10). Isso torna a switch expressão exaustiva.

Importante

Para obter informações sobre os padrões compatíveis com a switch expressão e mais exemplos, consulte Padrões.

O resultado de uma switch expressão é o valor da expressão do primeiro switch braço de expressão cujo padrão corresponde à expressão de entrada e cujo protetor de maiúsculas e minúsculas, se presente, é avaliado como true. Os switch braços de expressão são avaliados em ordem de texto.

O compilador gera um erro quando um braço de expressão inferior switch não pode ser escolhido porque um braço de expressão superior switch corresponde a todos os seus valores.

Guardas de caso

Um padrão pode não ser expressivo o suficiente para especificar a condição para a avaliação da expressão de um braço. Nesse caso, você pode usar um guarda de maiúsculas e minúsculas. Um guarda de maiúsculas e minúsculas é outra condição que deve ser atendida junto com um padrão correspondente. Um guarda de maiúsculas de minúsculas deve ser uma expressão booliana. Especifique um guarda de maiúsculas e minúsculas após a when palavra-chave que segue um padrão, como mostra o exemplo a seguir:

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

O exemplo anterior usa padrões de propriedade com padrões de var aninhados.

Expressões de comutador não exaustivas

Se nenhum dos padrões de uma switch expressão corresponder a um valor de entrada, o runtime gerará uma exceção. No .NET Core 3.0 e versões posteriores, a exceção é um System.Runtime.CompilerServices.SwitchExpressionException. No .NET Framework, a exceção é um InvalidOperationException. Na maioria dos casos, o compilador gera um aviso se uma switch expressão não manipula todos os valores de entrada possíveis. Os padrões de lista não geram um aviso quando todas as entradas possíveis não são tratadas.

Dica

Para garantir que uma switch expressão manipule todos os valores de entrada possíveis, forneça um switch braço de expressão com um padrão de descarte.

Especificação da linguagem C#

Para obter mais informações, consulte a switch seção de expressão da nota de proposta de recurso.

Consulte também