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

As ifinstruções , if-else, e switch selecionam instruções a executar entre muitos caminhos possíveis com base no valor de uma expressão. A if instrução executa uma instrução somente se uma expressão booleana fornecida for avaliada como true. A if-else instrução permite-lhe escolher qual dos dois caminhos de código seguir com base numa expressão booleana. A switch instrução seleciona uma lista de instruções para executar com base em uma correspondência de padrão com uma expressão.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento linguístico.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

Declaração if

Uma declaração pode ter qualquer uma if das duas formas seguintes:

• 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 booleana, 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 executa seu corpo somente se uma expressão booleana for avaliada como true, como mostra o 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 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}");
    }
}

Num contexto de expressão, use o operador ?:condicional para avaliar uma das duas expressões com base no valor de uma expressão booleana.

Declaração switch

A switch instrução seleciona uma série de instruções a executar com base numa correspondência de padrão com uma expressão de correspondência, como mostra o exemplo seguinte:

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 switch afirmação utiliza os seguintes padrões:

• Um padrão relacional: 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 suportados switch pela instrução, 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 ocorrência. Se uma expressão de correspondência não corresponder a nenhum padrão de maiúsculas e minúsculas e não default houver maiúsculas e minúsculas, o controle cairá por meio de uma switch instrução.

Uma switch instrução executa a lista de instruções na primeira seção de switch cujo padrão de maiúsculas e minúsculas corresponde a uma expressão de correspondência e cujo protetor de caso, se presente, é avaliado como true. Uma switch instrução avalia padrões de caso em 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á trata do caso ou quando o padrão é impossível de corresponder.

Observação

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

Você pode especificar vários padrões de maiúsculas e minúsculas 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 cair de uma seção de switch para a próxima. Como mostram os exemplos nesta seção, normalmente você usa a break instrução no final de cada seção de switch 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 queda e passar o controle para outra seção de switch, você pode usar a goto instrução.

Importante

Cada secção de interruptores deve terminar com , breakgoto, ou return. Passar de uma seção de switch para a próxima gera um erro de compilador. No entanto, pode aplicar vários rótulos de interruptores à mesma secção de interruptor, como case < 0: no exemplo anterior. Essa escolha deliberada de design permite lidar de forma concisa com vários casos que compartilham a mesma lógica ou interdependente.

Em um contexto de expressão, você pode usar a expressão para avaliar uma única expressão a partir de uma lista de expressões candidatas switch 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 é tipicamente usada em contextos de retorno de valor e atribuição de valor, frequentemente como membros corpos de expressão.
• Uma secção de caso de expressão switch não pode estar vazia, mas uma secção de caso de instrução switch pode.

Protetores de caixa

Um padrão de caso pode não ser suficientemente expressivo para especificar a condição para a execução da secção do comutador. Nesse caso, use um protetor de caso. O estado deve ser cumprido com um padrão correspondente. Um guarda-caso deve ser uma expressão booleana. Especifique um case guard após a when palavra-chave que segue um padrão, como mostra o exemplo seguinte:

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, consulte as seguintes seções da especificação da linguagem C#:

• A if declaração
• A switch declaração

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

Ver também

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