Instructions de sélection (référence C#)

Les instructions suivantes sélectionnent les instructions à exécuter à partir de plusieurs instructions possibles en fonction de la valeur d’une expression :

  • if Instruction: sélectionne une instruction à exécuter en fonction de la valeur d’une expression booléenne.
  • switch Instruction: sélectionne une liste d’instructions à exécuter en fonction d’une correspondance de modèle avec une expression.

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 le montre 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 partie exécute son corps uniquement si une expression booléenne prend true la valeur, comme le montre 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 if instructions pour vérifier plusieurs conditions, comme le montre 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.

Instruction switch

L' switch instruction sélectionne une liste d’instructions à exécuter en fonction d’une correspondance de modèle avec une expression de correspondance, comme le montre 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' switch instruction utilise les modèles suivants :

Important

Pour plus d’informations sur les modèles pris en charge par l' switch instruction, consultez patterns.

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 aucun default cas, le contrôle passe par une switch instruction.

Une switch instruction exécute la liste d’instructions dans la première section de commutateur dont le modèle de cas correspond à une expression de correspondance et dont la protection de la casse, si elle est présente, prend la valeur true . 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 une casse inaccessible. C’est un cas qui est déjà géré par un majuscule ou dont le modèle est impossible à faire correspondre.

Notes

Le default cas peut apparaître à n’importe quel endroit dans une switch instruction. Indépendamment de sa position, le default cas est toujours évalué en dernier et uniquement si tous les autres modèles de cas ne sont pas mis en correspondance.

Vous pouvez spécifier plusieurs modèles de cas pour une section d’une switch instruction, comme le montre 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 switch instruction, le contrôle ne peut pas passer d’une section switch à la suivante. Comme le montrent les exemples de cette section, vous utilisez généralement l' break instruction à la fin de chaque section switch pour passer le contrôle en dehors d’une switch instruction. Vous pouvez également utiliser les instructions Return et throw pour passer le contrôle en dehors d’une switch instruction. Pour imiter le comportement de passage et passer le contrôle à une autre section switch, vous pouvez utiliser l' goto instruction.

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

Protecteurs de cas

Un modèle de cas 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 de cas. Il s’agit d’une condition supplémentaire qui doit être satisfaite avec un modèle correspondant. Une protection de cas doit être une expression booléenne. Vous spécifiez un garde de cas après le when mot clé qui suit un modèle, comme le montre 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 relationnelsimbriqués.

Prise en charge des versions linguistiques

L' switch instruction prend en charge les critères spéciaux qui commencent par C# 7,0.

Dans C# 6 et les versions antérieures, vous utilisez l' switch instruction avec les limitations suivantes :

  • Une expression de correspondance doit être de l’un des types suivants : char, String, bool, un type numérique intégral ou un type enum .
  • Seules les expressions constantes sont autorisées dans les case étiquettes.

spécification du langage C#

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

Pour plus d’informations sur les fonctionnalités introduites dans C# 7,0 et versions ultérieures, consultez les notes de proposition de fonctionnalités suivantes :

Voir aussi