Instruções de seleção – if, if-else e switch

As instruções if, if-else e switch selecionam instruções a serem executadas de vários caminhos possíveis com base no valor de uma expressão. A instrução if executará uma instrução somente se uma expressão booliana fornecida for avaliada como true. A instrução if-else permite que você escolha qual dos dois caminhos de código seguir com base em uma expressão booliana. 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.

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: para comparar um resultado de expressão com uma constante.
• Um padrão constante: testa se o resultado de uma expressão é igual a uma constante.

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 houver nenhum caso de default, o controle passará por uma instrução switch.

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.

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 instrução switch, 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#:

• Instrução if
• Instrução switch

Para saber mais sobre padrões, confira a seção Padrões e padrões correspondentes da especificação da linguagem C#.

Confira também

• Operador condicional ?:
• Operadores lógicos
• Padrões
• Expressão switch
• Adicionar casos ausentes à instrução switch (regra de estilo IDE0010)