Instructions de sélection : ifif-else et switch

Les instructions if, if-else et switch sélectionnent les instructions à exécuter parmi différents chemins possibles en fonction de la valeur d’une expression. L’ifinstruction exécute une instruction uniquement si une expression booléenne fournie prend la valeur true. L’if-else instruction vous permet de choisir les deux chemins de code à suivre en fonction d’une expression booléenne. L’switchinstruction sélectionne une liste d’instructions à exécuter sur la base de critères spéciaux avec une expression.

Instruction if

Une instruction if peut se présenter sous l’une des deux formes suivantes :

• Une instruction if comportant une partie else sélectionne l’une des deux instructions à exécuter en fonction de la valeur d’une expression booléenne, comme l’illustre l’exemple suivant :

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

• Une instruction if sans partie else n’exécute son corps que si une expression booléenne prend la valeur true, comme l’illustre l’exemple suivant :

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

Vous pouvez imbriquer des instructions if pour vérifier différentes conditions, comme l’illustre l’exemple suivant :

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

Dans le contexte d’une expression, vous pouvez utiliser l’opérateur conditionnel ?: pour évaluer l’une des deux expressions en fonction de la valeur d’une expression booléenne.

Instruction switch

L’instruction switch sélectionne une liste d’instructions à exécuter en fonction de critères spéciaux avec une expression de correspondance, comme l’illustre l’exemple suivant :

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

Dans l’exemple précédent, l’instruction switch utilise les modèles suivants :

• Un modèle relationnel : pour comparer un résultat d’expression à une constante.
• Modèle constant : permet de tester si le résultat d’une expression est égal à une constante.

L’exemple précédent illustre également la casse default. La casse default spécifie les instructions à exécuter lorsqu’une expression de correspondance ne correspond à aucun autre modèle de casse. Si une expression de correspondance ne correspond à aucun modèle de casse et qu’il n’y a pas de casse default, le contrôle passe à une instruction switch.

Une instruction switch exécute la liste d’instructions de la première section switch dont le modèle de casse correspond à une expression de correspondance et dont la protection contre la casse, le cas échéant, prend la valeur true. Une instruction switch évalue les modèles de casse dans l’ordre du texte, de haut en bas. Le compilateur génère une erreur lorsqu’une instruction switch contient une casse inaccessible. Il s’agit d’une casse déjà traitée par une majuscule ou dont le modèle est impossible à mettre en correspondance.

Vous pouvez spécifier plusieurs modèles de casse pour une section d’une instruction switch, comme l’illustre l’exemple suivant :

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

Dans une instruction switch, le contrôle ne peut pas passer d’une section switch à une autre. Comme le montrent les exemples de cette section, l’instruction break est généralement utilisée à la fin de chaque section switch pour transmettre le contrôle à partir d’une instruction switch. Vous pouvez également utiliser les instructions return et throw pour transmettre le contrôle à partir d’une instruction switch. Pour imiter le comportement de passage et transmettre le contrôle à d’autres sections switch, vous pouvez utiliser l’instruction goto.

Dans le contexte d’une expression, vous pouvez utiliser l’expression switch pour évaluer une seule expression à partir d’une liste d’expressions candidates basées sur des critères spéciaux avec une expression.

Protections contre la casse

Un modèle de casse peut ne pas être suffisamment expressif pour spécifier la condition d’exécution de la section switch. Dans ce cas, vous pouvez utiliser une protection contre la casse. Il s’agit d’une condition supplémentaire qui doit être satisfaite avec un modèle correspondant. Une protection contre la casse doit être une expression booléenne. Vous spécifiez une protection contre la casse après le mot clé when qui suit un modèle, comme l’illustre l’exemple suivant :

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

L’exemple précédent utilise des modèles positionnels avec des modèles relationnels imbriqués.

spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

• Instruction if
• Instruction switch

Pour plus d’informations sur les modèles, consultez la section Modèles et correspondances de modèles de la spécification du langage C#.

Voir aussi

• Opérateur conditionnel ?:
• Opérateurs logiques
• Modèles
• switch, expression
• Ajouter des casses manquantes à l’instruction switch (règle de style IDE0010)