Instructions de sélection - if, if-elseet switch

Les ifinstructions , if-else et switch les instructions sélectionnent des instructions à exécuter à partir de nombreux chemins possibles en fonction de la valeur d’une expression. L’instructionif exécute une instruction uniquement si une expression booléenne fournie prend truela valeur . L’instructionif-else vous permet de choisir les deux chemins de code à suivre en fonction d’une expression booléenne. L’instructionswitch sélectionne une liste d’instructions à exécuter en fonction d’une correspondance de modèle avec une expression.

L’instruction if.

Une if instruction peut être l’une des deux formes suivantes :

• Une if instruction avec une else partie 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 if instruction sans else composant exécute son corps uniquement si une expression truebooléenne prend la valeur , 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 if des instructions pour vérifier plusieurs 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 un contexte d’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.

L’instruction switch.

L’instruction switch sélectionne une liste d’instructions à exécuter en fonction d’une correspondance de modèle 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 :

• Modèle relationnel : pour comparer un résultat d’expression à une constante.
• Modèle constant : testez si un résultat d’expression est égal à une constante.

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

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

Vous pouvez spécifier plusieurs modèles de cas pour une section d’une switch instruction, 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, le contrôle ne peut pas passer d’une switch section switch à l’autre. Comme le montrent les exemples de cette section, vous utilisez généralement l’instruction break à la fin de chaque section switch pour passer le contrôle d’une switch instruction. Vous pouvez également utiliser les instructions return et throw pour transmettre le contrôle d’une switch instruction. Pour imiter le comportement de basculement et passer le contrôle à d’autres sections switch, vous pouvez utiliser l’instructiongoto.

Dans un contexte d’expression, vous pouvez utiliser l’expressionswitch pour évaluer une expression unique à partir d’une liste d’expressions candidates en fonction d’une correspondance de modèle avec une expression.

Gardes de cas

Un modèle de cas peut ne pas être suffisamment expressif pour spécifier la condition pour l’exécution de la section switch. Dans ce cas, vous pouvez utiliser un garde de cas. Il s’agit d’une condition supplémentaire qui doit être satisfaite avec un modèle mis en correspondance. Un garde de casse doit être une expression booléenne. Vous spécifiez une protection de casse après le when mot clé 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# :

• L’instruction if
• L’instruction switch

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

Voir aussi

• Opérateur conditionnel ?:
• Opérateurs logiques
• Modèles
• Expression switch
• Ajouter des cas manquants à l’instruction switch (règle de style IDE0010)