Compartilhar via

expressão switch – expressões de padrões correspondentes usando a palavra-chave switch

  • Artigo

Você pode usar a expressão switch 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 saída. Para obter informações sobre a instrução switch que dá suporte à semântica semelhante a switch em um contexto de instrução, consulte a seção de switchinstrução do artigo Instruções de seleção.

O exemplo a seguir demonstra uma expressão switch, que converte valores de um enum representando direções visuais 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 expressão switch:

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

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

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

Importante

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

O resultado de uma expressão switch é o valor da expressão do primeiro braço da expressão switch cujo padrão corresponde à expressão de entrada, e cujo protetor de maiúsculas e minúsculas, se presente, é avaliado como true. Os braços da expressão switch 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.

Protetores de maiúsculas e minúsculas

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 protetor de maiúsculas e minúsculas. Uma proteção de caso é outra condição que deve ser atendida junto com um padrão correspondente. Um protetor de maiúsculas e minúsculas deve ser uma expressão booliana. Especifique um protetor de maiúsculas e minúsculas após a palavra-chave when 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 aninhados do var.

Expressões de switch não exaustivas

Se nenhum dos padrões de uma expressão switch 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 expressão switch 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 expressão switch manipule todos os valores de entrada possíveis, forneça um braço de expressão switch com um padrão de descarte.

Especificação da linguagem C#

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

Confira também