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

As ifinstruções e switch instruções selecionam instruções a serem executadas de muitos caminhos possíveis com base no valor de uma expressãoif-else. A if instrução executará uma instrução somente se uma expressão booliana fornecida for avaliada como true. A if-else instrução permite que você escolha quais dos dois caminhos de código seguir com base em uma expressão booliana. A switch instruçã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 if instrução pode ser qualquer uma das duas formas a seguir:

• Uma if instrução com uma else parte 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 if instrução sem uma else parte executará seu corpo somente se uma expressão booliana for avaliada, como mostra o exemplo a trueseguir:

  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 if instruções 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 switch instrução 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: comparar um resultado de expressão com uma constante.
• Um padrão constante: testar se um resultado de expressão é igual a uma constante.

O exemplo anterior também demonstra o default caso. O default caso 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 switch instrução executa a lista de instruções na primeira seção de comutador cujo padrão de caso corresponde a uma expressão de correspondência e cujo guarda de maiúsculas e minúsculas, se presente, é avaliado como true. Uma switch instrução avalia os padrões de caso na ordem de texto de cima para baixo. O compilador gera um erro quando uma switch instrução contém um caso inacessível. Esse é um caso que já é tratado por uma maiúscula ou cujo padrão é impossível de corresponder.

Você pode especificar vários padrões de caso para uma seção de uma switch instrução, 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 mostram os exemplos desta seção, normalmente você usa a break instrução no final de cada seção de comutador para passar o controle para fora de uma switch instrução. Você também pode usar as instruções return e throw para passar o controle de uma switch instrução. Para imitar o comportamento de fall-through e passar o controle para outra seção de comutador, você pode usar a goto instrução.

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

Guardas de caso

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

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#:

• A instrução if
• A instrução switch

Para obter mais informações sobre padrões, consulte a seção Padrões e correspondência de padrões da especificação da linguagem C#.

Consulte também

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