Partage via

Opérateurs de comparaison (référence C#)

Les < comparaisons (inférieures ou >égales)<= (inférieures ou égales)>= et (supérieures ou égales), également appelées opérateurs relationnels, comparent leurs opérandes. Tous les types numériques intégraux et à virgule flottante prennent en charge ces opérateurs.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Remarque

Pour les ==opérateurs , , <=>>=<et si l’un des opérandes n’est pas un nombre (Double.NaN ou Single.NaN), le résultat de l’opération est .false Ce comportement signifie que la NaN valeur n’est pas supérieure, inférieure ou égale à une autre double valeur (ou float) y compris NaN. Pour plus d’informations et d’exemples, consultez l’article ou Double.NaN l’article Single.NaN de référence.

Le type char prend également en charge les opérateurs de comparaison. Lorsque vous utilisez char des opérandes, les codes de caractères correspondants sont comparés.

Les types d’énumération prennent également en charge les opérateurs de comparaison. Pour les opérandes du même type d’énumération , les valeurs correspondantes du type intégral sous-jacent sont comparées.

Les opérateurs vérifient si leurs opérandes sont égaux ou non.==!=

Inférieur à l’opérateur <

L’opérateur < retourne true si son opérande de gauche est inférieur à son opérande de droite, false sinon :

Console.WriteLine(7.0 < 5.1);   // output: False
Console.WriteLine(5.1 < 5.1);   // output: False
Console.WriteLine(0.0 < 5.1);   // output: True

Console.WriteLine(double.NaN < 5.1);   // output: False
Console.WriteLine(double.NaN >= 5.1);  // output: False

Supérieur à l’opérateur >

L’opérateur > retourne true si son opérande de gauche est supérieur à son opérande de droite, false sinon :

Console.WriteLine(7.0 > 5.1);   // output: True
Console.WriteLine(5.1 > 5.1);   // output: False
Console.WriteLine(0.0 > 5.1);   // output: False

Console.WriteLine(double.NaN > 5.1);   // output: False
Console.WriteLine(double.NaN <= 5.1);  // output: False

Opérateur inférieur ou égal <=

L’opérateur <= retourne true si son opérande de gauche est inférieur ou égal à son opérande de droite. Sinon, elle retourne false:

Console.WriteLine(7.0 <= 5.1);   // output: False
Console.WriteLine(5.1 <= 5.1);   // output: True
Console.WriteLine(0.0 <= 5.1);   // output: True

Console.WriteLine(double.NaN > 5.1);   // output: False
Console.WriteLine(double.NaN <= 5.1);  // output: False

Opérateur supérieur ou égal >=

L’opérateur >= retourne true si son opérande de gauche est supérieur ou égal à son opérande de droite. Sinon, elle retourne false:

Console.WriteLine(7.0 >= 5.1);   // output: True
Console.WriteLine(5.1 >= 5.1);   // output: True
Console.WriteLine(0.0 >= 5.1);   // output: False

Console.WriteLine(double.NaN < 5.1);   // output: False
Console.WriteLine(double.NaN >= 5.1);  // output: False

Surcharge des opérateurs

Vous pouvez surcharger les opérateurs , et >=><=les <opérateurs dans un type défini par l’utilisateur.

Si vous surchargez l’un des ou > opérateurs, vous devez surcharger à la < fois < et >. Si vous surchargez l’un des ou >= opérateurs, vous devez surcharger à la <= fois <= et >=.

Spécification du langage C#

Pour plus d’informations, consultez la section Opérateurs relationnels et de test de type de la spécification du langage C#.

Voir aussi

  • Last updated on