Opérateurs C#

Tip

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent déjà au moins un langage de programmation et apprennent C#. Si vous débutez avec la programmation, commencez par commencer par les didacticiels De prise en main .

Venant d’une autre langue ? La plupart des opérateurs de cet article (+, , -, &&%==!/*!=<||, , >opérateurs de comparaison et =) fonctionnent comme dans Java, C++ et JavaScript. Les principales surprises pour les débutants sont le comportement de la division entière, la distinction entre les formes préfixée et postfixée pour ++/--, et la manière dont l’affectation composée reconvertit le résultat dans le type de l’expression de gauche.

Un opérateur combine un ou plusieurs opérandes en une seule valeur. Vous connaissez déjà les expressions et la priorité des opérateurs à partir d’expressions C# ; Cet article explique plus en détail les opérateurs spécifiques que vous utiliserez tous les jours.

Opérateurs arithmétiques

Les cinq opérateurs arithmétiques effectuent des calculs numériques.

Operator Name Example Résultat
+ Ajout 10 + 3 13
- Soustraction 10 - 3 7
* Multiplication 10 * 3 30
/ Division 10 / 3 3
% Solde 10 % 3 1 
int apples = 10;
int oranges = 3;

Console.WriteLine(apples + oranges);  // => 13  (addition)
Console.WriteLine(apples - oranges);  // => 7   (subtraction)
Console.WriteLine(apples * oranges);  // => 30  (multiplication)
Console.WriteLine(apples / oranges);  // => 3   (integer division: truncates toward zero)
Console.WriteLine(apples % oranges);  // => 1   (remainder)

// Integer division always truncates toward zero — the fractional part is discarded
int result = 7 / 2;
Console.WriteLine(result); // => 3, not 3.5

// Truncation applies to negative results too: -7 / 2 is -3, not -4
int negResult = -7 / 2;
Console.WriteLine(negResult); // => -3

// To get a decimal result, at least one operand must be a double or float
double precise = 7.0 / 2;
Console.WriteLine(precise); // => 3.5

// Remainder with negative operands: the sign of the result matches the dividend
Console.WriteLine(-7 % 3);  // => -1  (-7 = 3 × -2 + (-1))
Console.WriteLine(7 % -3);  // => 1   ( 7 = -3 × -2 + 1)

La division entière tronque vers zéro. Lorsque les deux opérandes sont des entiers, / ignore la partie fractionnaire : 7 / 2 est 3, et non 3.5. La troncation se fait vers zéro, et non vers le nombre le plus petit : -7 / 2 vaut -3 (et non -4). Pour obtenir un résultat décimal, utilisez au moins un opérande de type à virgule flottante : 7.0 / 2 correspond à 3.5. Cela diffère de certaines langues où / produit toujours un résultat à virgule flottante.

Le reste (%) renvoie le reste d’une division entière : 10 % 3 vaut 1 parce que 10 = 3 × 3 + 1. Il est utile de parcourir une plage fixe (index % length), de tester la divisibilité (n % 2 == 0) et d’extraire des chiffres. Avec des opérandes négatifs, le signe du résultat correspond au signe du dividende (l’opérande gauche) : -7 % 3 est -1 et 7 % -3 est 1.

Opérateurs unaires

Les opérateurs unaires agissent sur un opérande unique.

int temperature = 20;
int windChill = -5;

int heatIndex = +temperature;   // unary +: value unchanged (rarely needed)
int coldFactor = -windChill;    // unary -: negates the value → 5

Console.WriteLine(heatIndex);   // => 20
Console.WriteLine(coldFactor);  // => 5

bool isRaining = false;
bool isSunny = !isRaining;     // logical NOT: flips true/false
Console.WriteLine(isSunny);    // => True
  • +x (plus unaire) : laisse la valeur inchangée ; rarement écrit explicitement mais valide.
  • -x (unaire moins) : annule la valeur.
  • !x (NON logique) — inverse true en false et false en true. Vous utiliserez ! souvent : if (!list.Contains(item)).

Incrémenter et décrémenter

++ ajoute 1 et -- soustrait 1. Les deux ont un formulaire de préfixe et un formulaire postfix qui diffèrent dans la valeur retournée :

int counter = 5;

// Prefix: increment first, then use the new value
int a = ++counter;
Console.WriteLine(a);       // => 6
Console.WriteLine(counter); // => 6

// Postfix: use the current value first, then increment
int b = counter++;
Console.WriteLine(b);       // => 6  (value before increment)
Console.WriteLine(counter); // => 7  (incremented after)

// Decrement works the same way
int score = 10;
Console.WriteLine(score--); // => 10 (current value; score becomes 9)
Console.WriteLine(score);   // => 9
  • Préfixe (++i, --i) : incrémente ou décrémente d’abord la variable, puis retourne la nouvelle valeur.
  • Postfix (i++, i--) : retourne d’abord la valeur actuelle , puis incrémente ou décrémente la variable.

Quand ++ ou -- apparaît comme une instruction isolée (et ne fait pas partie d’une expression plus large), le préfixe et le suffixe ont le même effet. La distinction est importante uniquement lorsque le résultat est utilisé , par exemple, dans une affectation ou en tant qu’argument de méthode.

Opérateurs relationnels

Les opérateurs relationnels comparent deux valeurs et retournent un bool.

Operator Meaning Example
< Inférieur à speed < limit
> Supérieur à speed > limit
<= Inférieur ou égal à score <= 100
>= Supérieur ou égal à score >= 0 
int speed = 75;
int limit = 60;

Console.WriteLine(speed > limit);   // => True   (greater than)
Console.WriteLine(speed < limit);   // => False  (less than)
Console.WriteLine(speed >= limit);  // => True   (greater than or equal)
Console.WriteLine(speed <= limit);  // => False  (less than or equal)

// Relational operators work on all numeric types and char
// char comparison uses the character's numeric Unicode code point, not alphabetical position
// 'B' (U+0042, value 66) is less than 'A' (U+0041, value 65)? No — 'A' (65) < 'B' (66)
char grade = 'B';
Console.WriteLine(grade >= 'A' && grade <= 'C'); // => True  ('A'=65 <= 'B'=66 <= 'C'=67)

Les opérateurs relationnels fonctionnent sur tous les types numériques et char. Pour char, la comparaison utilise la valeur numérique du point de code Unicode du caractère, et non aucun ordre alphabétique ou spécifique au domaine. Dans l’exemple de classe ci-dessus, 'B' est supérieur ou égal à 'A' car 'B' a la valeur Unicode 66 et 'A' a la valeur Unicode 65 : les nombres déterminent la comparaison, et non la signification des notes de lettre.

Opérateurs d’égalité

== et != vérifiez si deux valeurs sont égales ou non. != est true quand les opérandes ne sont pas égaux et false quand ils sont.

int expected = 42;
int actual = 42;

Console.WriteLine(actual == expected);  // => True   (values are equal)
Console.WriteLine(actual != expected);  // => False  (true when values are not equal)

string name = "Alice";
Console.WriteLine(name == "Alice");  // => True   (string content matches)
Console.WriteLine(name == "alice");  // => False  (case-sensitive)

int x = 5;
Console.WriteLine(x == 10);  // => False

Pour les types numériques et string, l’égalité teste les valeurs. Pour les types de référence, la valeur par défaut est l’identité (si deux variables pointent vers le même objet), mais de nombreux types, y compris string et record substituent cela pour comparer le contenu. Pour obtenir l’image complète : fonctionnement de l’égalité entre les types valeur, les types de référence, les enregistrements et les structs , consultez comparaisons d’égalité.

Note

C# n’a pas d’opérateur === . L’écriture === est une erreur au moment de la compilation :

// This does not compile — C# has no === operator
bool same = (x === 10);

Si vous venez de JavaScript, utilisez == pour comparer les valeurs (en C#, == effectue déjà une comparaison par valeur pour les types primitifs et les chaînes). Un bogue connexe fréquent consiste à écrire accidentellement = (affectation) au lieu de == (test d’égalité). Le compilateur détecte les formes les plus courantes, mais vérifiez bien toute condition if qui contient =.

Opérateurs logiques conditionnels

&& (AND) et || (OR) combinent des bool expressions.

int age = 20;
bool hasTicket = true;

// && (AND): both sides must be true
bool canEnter = age >= 18 && hasTicket;
Console.WriteLine(canEnter); // => True

// || (OR): at least one side must be true
bool freeEntry = age < 5 || age >= 65;
Console.WriteLine(freeEntry); // => False

// Short-circuit: right side is skipped when the result is already determined
// Here, items.Count is never called if items is null
List<string>? items = null;
bool hasItems = items != null && items.Count > 0;
Console.WriteLine(hasItems); // => False  (short-circuits; no NullReferenceException)

Les deux opérateurs sont à court-circuit : ils n’évaluent pas l’opérande de droite lorsque le résultat est déjà déterminé.

  • && retourne false dès que le côté gauche est false. Le côté droit n’est jamais évalué.
  • || retourne true dès que le côté gauche est true. Le côté droit n’est jamais évalué.

Le comportement de court-circuit présente un avantage pratique : vous pouvez protéger en toute sécurité une opération sur le côté droit avec une vérification null sur le côté gauche, comme l’illustre l’exemple ci-dessus. Si items est null, && s’arrête là — items.Count n’est jamais appelé, donc aucune NullReferenceException n’est levée.

Opérateur conditionnel ?:

L’opérateur conditionnel (également appelé opérateur ternaire ) évalue l’une des deux expressions en fonction d’une condition :

condition ? value-when-true : value-when-false

int temperature2 = 35;

// condition ? value-when-true : value-when-false
string weather = temperature2 > 30 ? "hot" : "comfortable";
Console.WriteLine(weather); // => hot

// Only the matching branch evaluates — the other branch is never run
int divisor = 0;
// The division 10 / divisor is never evaluated because divisor == 0 is true
int safe = divisor == 0 ? -1 : 10 / divisor;
Console.WriteLine(safe); // => -1

L’opérateur ?: évalue toujours exactement une branche , le côté qui ne correspond pas à la condition n’est jamais évalué. Cela permet d’utiliser une expression sur l’un des côtés qui échouerait pour d’autres entrées, à condition que la condition la protège correctement.

Utiliser ?: pour des choix simples et inline. Dans le cas de conditions à branches multiples ou de blocs de code, une instruction if/else est généralement plus claire.

Opérateurs d'assignation

L’opérateur d’affectation = simple stocke une valeur dans une variable :

int level = 1;  // declaration + initialization
level = 5;      // reassignment

L’affectation en C# est associative à droite, ce qui signifie que a = b = c = 0 s’évalue de droite à gauche : c reçoit 0, puis b reçoit a, puis 0 reçoit 0.

Assignation composée

Les opérateurs d’affectation composée combinent une opération binaire avec l’affectation :

Operator Équivalent à
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y 
int level = 1;
level = 5;          // simple assignment: replaces the value
Console.WriteLine(level); // => 5

// Compound assignment: short form of binary operation + assignment
int hp = 100;
hp += 20;   // same as: hp = hp + 20
Console.WriteLine(hp); // => 120
hp -= 10;   // same as: hp = hp - 10
Console.WriteLine(hp); // => 110
hp *= 2;    // same as: hp = hp * 2
Console.WriteLine(hp); // => 220
hp /= 3;    // same as: hp = hp / 3 (integer division)
Console.WriteLine(hp); // => 73
hp %= 7;    // same as: hp = hp % 7
Console.WriteLine(hp); // => 3

L’affectation composée est plus qu’un simple raccourci. Il évalue le membre de gauche exactement une fois, puis convertit le résultat vers le type du membre de gauche. Cela importe quand le côté gauche a des effets secondaires (comme un indexeur de tableau), et c’est pourquoi l’affectation composée sur une byte variable se compile sans cast explicite alors que le formulaire développé ne le fait pas :

// Assignment is right-associative: evaluated right to left
int a2, b2, c2;
a2 = b2 = c2 = 0;     // c2 = 0 first, then b2 = 0, then a2 = 0
Console.WriteLine($"{a2} {b2} {c2}"); // => 0 0 0

// Compound assignment evaluates the left side once and converts back to the LHS type
byte small = 200;
small += 10;  // equivalent to: small = (byte)(small + 10); result is 210
Console.WriteLine(small); // => 210

small += 10 compile, car le compilateur insère automatiquement la conversion restrictive , le résultat, 210correspond à la byte plage comprise entre 0 et 255. small = small + 10 nécessiterait une conversion de type explicite en (byte), car les opérations arithmétiques convertissent les deux opérandes en int.

Autres opérateurs C#

Cet article traite des opérateurs que vous rencontrerez le plus dans le code quotidien. Le langage C# inclut plus d’opérateurs utiles dans des scénarios spécifiques :

  • Opérateurs de décalage (<<, , >>>>>) : décaler les bits d’une valeur entière gauche ou droite par un nombre spécifié de positions. Opérateurs logiques au niveau du bit et entier (&, , |^, ~) : combiner ou inverser des valeurs entières un bit à la fois, utiles dans les indicateurs, les masques et le code de bas niveau : opérateurs de bits et de décalage
  • checked et unchecked — contrôler si le dépassement d’entier lève une exception (checked) ou encapsule en mode silencieux (unchecked) : activé et désactivé
  • Opérateurs de valeur Null (??, ?., ??=, ?[]) — permettent de gérer les valeurs null en toute sécurité en fournissant des valeurs par défaut ou en interrompant l’accès aux membres : Opérateurs de valeur Null
  • Opérateurs de test et de conversion de type (is, , astypeofcast) : vérifier ou convertir le type d’exécution d’une valeur : opérateurs de test de type et de cast(T)
  • Opérateurs de plage et d’indice (.., ^) — permettent de créer des plages et des indices relatifs à la fin pour découper des tableaux et des spans : Accès aux membres et opérateurs conditionnels de nullité
  • Affectation de déconstruction : décompresser un tuple ou un type dans des variables individuelles dans une seule expression : déconstruction des tuples et d’autres types

Voir aussi

  • Last updated on