Instructions de sélection - if, else et switch

Les ifinstructions et switchelse sélectionnent des instructions à exécuter à partir de nombreux chemins d’accès possibles en fonction de la valeur d’une expression. L’instructionif sélectionne une instruction à exécuter en fonction de la valeur d’une expression booléenne. Une if instruction peut être combinée avec else pour choisir deux chemins distincts en fonction de l’expression booléenne. L’instructionswitch 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 composant exécute son corps uniquement si une expression booléenne prend la valeur true, 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 if des 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’instruction switch 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’instruction switch utilise les modèles suivants :

  • Modèle relationnel (disponible en C# 9.0 et versions ultérieures) : pour comparer un résultat d’expression avec une constante.
  • Modèle de constante : testez si un résultat d’expression est égal à une constante.

Important

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

L’exemple précédent illustre également le default cas. La default casse 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 casse 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 de la première section de commutateur dont le modèle de casse correspond à trueune expression de correspondance et dont la protection de casse, le cas échéant, prend la valeur . Une switch instruction évalue les modèles de casse dans l’ordre du texte de haut en bas. Le compilateur génère une erreur lorsqu’une switch instruction contient un cas inaccessible. Il s’agit d’un cas qui est déjà géré par une majuscule ou dont le modèle est impossible à correspondre.

Notes

Le default cas peut apparaître à n’importe quel endroit dans une switch instruction. Quelle que soit sa position, la default casse est toujours évaluée en dernier et uniquement si tous les autres modèles de cas ne sont pas mis en correspondance, sauf si goto default est rencontré.

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 de commutateur à l’autre. Comme le montrent les exemples de cette section, vous utilisez généralement l’instruction break à la fin de chaque section de commutateur pour passer le contrôle d’une switch instruction. Vous pouvez également utiliser les instructions return et throw pour passer le contrôle d’une switch instruction. Pour imiter le comportement de basculement et passer le contrôle à une autre section de commutateur, 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.

Protections de casse

Un modèle de cas peut ne pas être suffisamment expressif pour spécifier la condition d’exécution de la section de commutateur. Dans ce cas, vous pouvez utiliser un protection contre la casse. Il s’agit d’une condition supplémentaire qui doit être remplie avec un modèle correspondant. Une protection 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 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 relationnels imbriqués.

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 l’instruction de correspondance switch de modèle, consultez les notes de proposition de fonctionnalités suivantes :

Voir aussi