Istruzioni di selezione: if, if-else e switch

Le istruzioni if, if-else e switch selezionano le istruzioni da eseguire da molti percorsi possibili in base al valore di un'espressione. L'istruzioneif esegue un'istruzione solo se un'espressione booleana specificata restituisce true. L'istruzioneif-else consente di scegliere quali dei due percorsi di codice seguire in base a un'espressione booleana. L'istruzioneswitch seleziona un elenco di istruzioni da eseguire in base a una corrispondenza di criteri con un'espressione.

Istruzione if

Un'istruzione if può essere una delle due forme seguenti:

• Un'istruzione if con una parte else seleziona una delle due istruzioni da eseguire in base al valore di un'espressione booleana, come illustrato nell'esempio seguente:

  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!");
      }
  }
  

• Un'istruzione if senza una parte else ne esegue il corpo solo se un'espressione booleana restituisce true, come illustrato nell'esempio seguente:

  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}");
  }
  

È possibile annidare istruzioni if per controllare più condizioni, come illustrato nell'esempio seguente:

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}");
    }
}

In un contesto di espressione è possibile usare l'operatore condizionale ?: per valutare una delle due espressioni in base al valore di un'espressione booleana.

Istruzione switch

L'istruzione switch seleziona un elenco di istruzioni da eseguire in base a una corrispondenza di criteri con un'espressione di corrispondenza, come illustrato nell'esempio seguente:

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;
    }
}

Nell'esempio precedente l'istruzione switch usa i modelli seguenti:

• Modello relazionale: per confrontare un risultato di un'espressione con una costante.
• Modello costante: verificare se un risultato di un'espressione è uguale a una costante.

L'esempio precedente illustra anche il caso default. Il caso default specifica le istruzioni da eseguire quando un'espressione di corrispondenza non corrisponde ad altri criteri di maiuscole e minuscole. Se un'espressione di corrispondenza non corrisponde ad alcun criterio di maiuscole e minuscole e non esiste alcuna distinzione tra maiuscole e minuscole default, il controllo passa attraverso un'istruzione switch.

Un'istruzione switch esegue l'elenco di istruzioni nella prima sezione switch il cui criterio di maiuscole e minuscole corrisponde a un'espressione di corrispondenza e la cui clausola guard maiuscole/minuscole, se presente, restituisce true. Un'istruzione switch valuta i criteri di maiuscole e minuscole in ordine di testo dall'alto verso il basso. Il compilatore genera un errore quando un'istruzione switch contiene un caso non raggiungibile. Si tratta di un caso già gestito da un maiuscolo o del cui criterio è impossibile trovare la corrispondenza.

È possibile specificare più criteri di maiuscole e minuscole per una sezione di un'istruzione switch, come illustrato nell'esempio seguente:

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;
    }
}

All'interno di un'istruzione switch, il controllo non può passare da una sezione switch alla successiva. Come illustrato negli esempi di questa sezione, in genere si usa l'istruzione break alla fine di ogni sezione switch per passare il controllo da un'istruzione switch. È inoltre possibile usare le istruzioni restituisci e genera per passare il controllo da un'istruzione switch. Per imitare il comportamento di fall-through e passare il controllo ad altre sezioni switch, è possibile usare l'istruzione goto.

In un contesto di espressione è possibile usare l'espressione switch per valutare una singola espressione da un elenco di espressioni candidate in base a una corrispondenza di criteri con un'espressione.

Clausola guard maiuscole/minuscole

Un criterio di maiuscole e minuscole potrebbe non essere sufficientemente espressivo per specificare la condizione per l'esecuzione della sezione switch. In questo caso, è possibile usare una clausola guard maiuscole/minuscole. Si tratta di una condizione aggiuntiva che deve essere soddisfatta insieme a un criterio corrispondente. Una clausola guard maiuscole/minuscole deve essere un'espressione booleana. Si specifica una clausola guard maiuscole/minuscole dopo la parola chiave when che segue un criterio, come illustrato nell'esempio seguente:

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;
    }
}

Nell'esempio precedente vengono usati criteri posizionali con criteri relazionali annidati.

Specifiche del linguaggio C#

Per altre informazioni, vedere le sezioni seguenti delle specifiche del linguaggio C#:

• L’istruzione if
• L’istruzione switch

Per altre informazioni sui criteri, vedere la sezione Criteri e criteri di ricerca della specifica del linguaggio C#.

Vedi anche

• Operatore condizionale ?:
• Operatori logici
• Criteri
• switch espressione
• Aggiungere casi mancanti all'istruzione switch (regola di stile IDE0010)