C# Language ? : Opérateur ternaire


Exemple

Renvoie l'une des deux valeurs en fonction de la valeur d'une expression booléenne.

Syntaxe:

condition ? expression_if_true : expression_if_false;

Exemple:

string name = "Frank";
Console.WriteLine(name == "Frank" ? "The name is Frank" : "The name is not Frank");

L'opérateur ternaire est associé à droite, ce qui permet d'utiliser des expressions ternaires composées. Ceci est fait en ajoutant des équations ternaires supplémentaires dans la position vraie ou fausse d'une équation ternaire parente. Des précautions doivent être prises pour assurer la lisibilité, mais cela peut être utile dans certaines circonstances.

Dans cet exemple, une opération ternaire composé évalue une clamp fonction et retourne la valeur courante si elle est comprise dans l'intervalle, le min valeur si elle est inférieure à la plage, ou le max de valeur si elle est supérieure à la plage.

light.intensity = Clamp(light.intensity, minLight, maxLight);

public static float Clamp(float val, float min, float max)
{
    return (val < min) ? min : (val > max) ? max : val;
}

Les opérateurs ternaires peuvent également être imbriqués, tels que:

a ? b ? "a is true, b is true" : "a is true, b is false" : "a is false"

// This is evaluated from left to right and can be more easily seen with parenthesis:

a ? (b ? x : y) : z

// Where the result is x if a && b, y if a && !b, and z if !a

Lors de l'écriture d'instructions ternaires composées, il est courant d'utiliser des parenthèses ou des indentations pour améliorer la lisibilité.

Les types de expression_if_true et expression_if_false doivent être identiques ou il doit y avoir une conversion implicite de l'un à l'autre.

condition ? 3 : "Not three"; // Doesn't compile because `int` and `string` lack an implicit conversion.

condition ? 3.ToString() : "Not three"; // OK because both possible outputs are strings.

condition ? 3 : 3.5; // OK because there is an implicit conversion from `int` to `double`. The ternary operator will return a `double`.

condition ? 3.5 : 3; // OK because there is an implicit conversion from `int` to `double`. The ternary operator will return a `double`.

Le type et les conditions de conversion s'appliquent également à vos propres classes.

public class Car
{}

public class SportsCar : Car
{}

public class SUV : Car
{}

condition ? new SportsCar() : new Car(); // OK because there is an implicit conversion from `SportsCar` to `Car`. The ternary operator will return a reference of type `Car`.

condition ? new Car() : new SportsCar(); // OK because there is an implicit conversion from `SportsCar` to `Car`. The ternary operator will return a reference of type `Car`.

condition ? new SportsCar() : new SUV(); // Doesn't compile because there is no implicit conversion from `SportsCar` to SUV or `SUV` to `SportsCar`. The compiler is not smart enough to realize that both of them have an implicit conversion to `Car`.

condition ? new SportsCar() as Car : new SUV() as Car; // OK because both expressions evaluate to a reference of type `Car`. The ternary operator will return a reference of type `Car`.