Instruções de seleção – ife elseswitch

As ifinstruções e switchelse selecionam instruções a serem executadas de muitos caminhos possíveis com base no valor de uma expressão. A ifinstrução seleciona uma instrução a ser executada com base no valor de uma expressão booliana. Uma if instrução pode ser combinada com else para escolher dois caminhos distintos com base na expressão booliana. A switchinstrução seleciona uma lista de instruções a ser executada com base em uma correspondência de padrão com uma expressão.

A instrução if

Uma instrução if pode ter uma das duas formas a seguir:

  • Uma instrução if com uma parte else seleciona uma das duas instruções a serem executadas com base no valor de uma expressão booliana, como mostra o exemplo a seguir:

    DisplayWeatherReport(15.0);  // Output: Cold.
    DisplayWeatherReport(24.0);  // Output: Perfect!
    
    void DisplayWeatherReport(double tempInCelsius)
    {
        if (tempInCelsius < 20.0)
        {
            Console.WriteLine("Cold.");
        }
        else
        {
            Console.WriteLine("Perfect!");
        }
    }
    
  • Uma instrução if sem uma parte else executará seu corpo somente se uma expressão booliana for avaliada como true, conforme mostrado no exemplo a seguir:

    DisplayMeasurement(45);  // Output: The measurement value is 45
    DisplayMeasurement(-3);  // Output: Warning: not acceptable value! The measurement value is -3
    
    void DisplayMeasurement(double value)
    {
        if (value < 0 || value > 100)
        {
            Console.Write("Warning: not acceptable value! ");
        }
    
        Console.WriteLine($"The measurement value is {value}");
    }
    

Você pode aninhar instruções if para verificar várias condições, como mostra o exemplo a seguir:

DisplayCharacter('f');  // Output: A lowercase letter: f
DisplayCharacter('R');  // Output: An uppercase letter: R
DisplayCharacter('8');  // Output: A digit: 8
DisplayCharacter(',');  // Output: Not alphanumeric character: ,

void DisplayCharacter(char ch)
{
    if (char.IsUpper(ch))
    {
        Console.WriteLine($"An uppercase letter: {ch}");
    }
    else if (char.IsLower(ch))
    {
        Console.WriteLine($"A lowercase letter: {ch}");
    }
    else if (char.IsDigit(ch))
    {
        Console.WriteLine($"A digit: {ch}");
    }
    else
    {
        Console.WriteLine($"Not alphanumeric character: {ch}");
    }
}

Em um contexto de expressão, você pode usar o operador condicional ?: para avaliar uma das duas expressões com base no valor de uma expressão booliana.

A instrução switch

A instrução switch seleciona uma lista de instruções a ser executada com base em uma correspondência de padrão com uma expressão de correspondência, como mostra o exemplo a seguir:

DisplayMeasurement(-4);  // Output: Measured value is -4; too low.
DisplayMeasurement(5);  // Output: Measured value is 5.
DisplayMeasurement(30);  // Output: Measured value is 30; too high.
DisplayMeasurement(double.NaN);  // Output: Failed measurement.

void DisplayMeasurement(double measurement)
{
    switch (measurement)
    {
        case < 0.0:
            Console.WriteLine($"Measured value is {measurement}; too low.");
            break;

        case > 15.0:
            Console.WriteLine($"Measured value is {measurement}; too high.");
            break;

        case double.NaN:
            Console.WriteLine("Failed measurement.");
            break;

        default:
            Console.WriteLine($"Measured value is {measurement}.");
            break;
    }
}

No exemplo anterior, a instrução switch usa os seguintes padrões:

  • Um padrão relacional (disponível em C# 9.0 e posterior): para comparar um resultado de expressão com uma constante.
  • Um padrão constante: teste se um resultado de expressão é igual a uma constante.

Importante

Para obter informações sobre os padrões com suporte na instrução switch, consulte Padrões.

O exemplo anterior também demonstra o caso default. O caso default especifica instruções a serem executadas quando uma expressão de correspondência não corresponde a nenhum outro padrão de caso. Se uma expressão de correspondência não corresponder a nenhum padrão de caso e não default houver nenhum caso, o controle passará por uma switch instrução .

Uma instrução switch executa a lista de instruções na primeira seção de comutador cujo padrão de caso corresponder a uma expressão de correspondência e cujo protetor de maiúsculas e minúsculas, se presente, for avaliado como true. Uma instrução switch avalia padrões de caso na ordem de texto de cima para baixo. O compilador gera um erro quando uma instrução switch contém um caso inacessível. Esse é um caso já tratado por um caso superior ou cujo padrão é impossível de corresponder.

Observação

O caso default pode aparecer em qualquer lugar dentro de uma instrução switch. Independentemente de sua posição, o default caso é sempre avaliado por último e somente se todos os outros padrões de caso não forem correspondidos, exceto se goto default for encontrado.

Você pode especificar vários padrões de caso para uma seção de uma instrução switch, como mostra o exemplo a seguir:

DisplayMeasurement(-4);  // Output: Measured value is -4; out of an acceptable range.
DisplayMeasurement(50);  // Output: Measured value is 50.
DisplayMeasurement(132);  // Output: Measured value is 132; out of an acceptable range.

void DisplayMeasurement(int measurement)
{
    switch (measurement)
    {
        case < 0:
        case > 100:
            Console.WriteLine($"Measured value is {measurement}; out of an acceptable range.");
            break;
        
        default:
            Console.WriteLine($"Measured value is {measurement}.");
            break;
    }
}

Dentro de uma switch instrução, o controle não pode passar de uma seção de comutador para a próxima. Como os exemplos nesta seção mostram, normalmente você usa a instrução break no final de cada seção de comutador para passar o controle para fora de uma instrução switch. Você também pode usar as instruções return e throw para passar o controle para fora de uma instrução switch. Para imitar o comportamento de fall-through e passar o controle para outra seção de comutador, você pode usar a instrução goto.

Em um contexto de expressão, 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.

Protetor de maiúsculas e minúsculas

Um padrão de caso pode não ser expressivo o bastante para especificar a condição da execução da seção de comutador. Nesse caso, você pode usar um protetor de maiúsculas e minúsculas. Essa é uma condição adicional 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:

DisplayMeasurements(3, 4);  // Output: First measurement is 3, second measurement is 4.
DisplayMeasurements(5, 5);  // Output: Both measurements are valid and equal to 5.

void DisplayMeasurements(int a, int b)
{
    switch ((a, b))
    {
        case (> 0, > 0) when a == b:
            Console.WriteLine($"Both measurements are valid and equal to {a}.");
            break;

        case (> 0, > 0):
            Console.WriteLine($"First measurement is {a}, second measurement is {b}.");
            break;

        default:
            Console.WriteLine("One or both measurements are not valid.");
            break;
    }
}

O exemplo anterior usa padrões posicionais com padrões relacionais aninhados.

Especificação da linguagem C#

Para obter mais informações, confira as seguintes seções da especificação da linguagem C#:

Para obter mais informações sobre a instrução de correspondência switch de padrões, consulte as seguintes notas de proposta de recurso:

Confira também