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

As ifinstruções e if-elseswitch instruções selecionam instruções a serem executadas de muitos caminhos possíveis com base no valor de uma expressão. 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 linguagem C# faz referência a documentos da versão mais recentemente lançada da linguagem C#. Ele também contém a documentação inicial para recursos em visualizações públicas para a próxima versão do idioma.

A documentação identifica qualquer recurso introduzido pela primeira vez nas três últimas versões do idioma ou nas versões prévias públicas atuais.

Dica

Para descobrir quando um recurso foi introduzido pela primeira vez em C#, consulte o artigo sobre o histórico de versão da linguagem C#.

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, use 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 série de instruções a serem executadas 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.

Importante

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

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 erro ocorre quando uma maiúscula já manipula o caso ou quando o padrão é impossível de corresponder.

Observação

O default caso pode aparecer em qualquer lugar dentro de uma switch instrução. Independentemente de sua posição, o default caso será avaliado somente se todos os outros padrões de caso não forem correspondidos ou a goto default; instrução for executada em uma das seções de comutador.

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.

Importante

Cada seção de comutador deve terminar com um break, gotoou return. A passagem de uma seção de comutador para a próxima gera um erro do compilador. No entanto, você pode aplicar vários rótulos de comutador à mesma seção de comutador, como case < 0: no exemplo anterior. Essa escolha de design deliberada permite lidar concisamente com vários casos que compartilham a mesma lógica ou interdependente.

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.

Importante

Diferenças entre a expressão switch e a instrução switch:

• A instrução switch é usada para controlar o fluxo de execução dentro de um bloco de código.
• A expressão switch normalmente é usada em contextos de retorno de valor e atribuição de valor, muitas vezes como membros aptos para expressão.
• uma seção de maiúsculas e minúsculas de expressão de opção não pode estar vazia, mas uma seção de maiúsculas e minúsculas de instrução switch pode.

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 switch. Nesse caso, use um guarda de maiúsculas e minúsculas. A condição 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:

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)