Opérateurs et expressions C#

C# fournit un certain nombre d’opérateurs. La plupart d’entre eux sont pris en charge par les types intégrés et vous permettent d’effectuer des opérations de base avec des valeurs de ces types. Ces opérateurs incluent les groupes suivants :

• Opérateurs arithmétiques qui effectuent des opérations arithmétiques avec des opérandes numériques
• Opérateurs de comparaison qui comparent des opérandes numériques
• Opérateurs logiques booléens qui effectuent des opérations logiques avec bool des opérandes
• Opérateurs de bits et de décalage qui effectuent des opérations de décalage ou au niveau du bit avec des opérandes des types intégraux
• Opérateurs d’égalité qui vérifient si leurs opérandes sont égaux ou non

En règle générale, vous pouvez surcharger ces opérateurs, autrement dit, spécifier le comportement de l’opérateur pour les opérandes d’un type défini par l’utilisateur.

Les expressions C# les plus simples sont des littéraux (par exemple, des nombres entiers et des nombres réels ) et des noms de variables. Vous pouvez les combiner en expressions complexes à l’aide d’opérateurs. La priorité des opérateurs et l’associativité déterminent l’ordre dans lequel les opérations d’une expression sont effectuées. Vous pouvez utiliser des parenthèses pour modifier l’ordre d’évaluation imposé par priorité d’opérateur et l’associativité.

Dans le code suivant, des exemples d’expressions se trouvent à droite des affectations :

int a, b, c;
a = 7;
b = a;
c = b++;
b = a + b * c;
c = a >= 100 ? b : c / 10;
a = (int)Math.Sqrt(b * b + c * c);

string s = "String literal";
char l = s[s.Length - 1];

List<int> numbers = [..collection];
b = numbers.FindLast(n => n > 1);

En règle générale, une expression produit un résultat et peut être incluse dans une autre expression. Un void appel de méthode est un exemple d’expression qui ne produit pas de résultat. Il peut être utilisé uniquement comme instruction, comme l’illustre l’exemple suivant :

Console.WriteLine("Hello, world!");

Voici d’autres types d’expressions fournies par C# :

• Expressions de chaîne interpolées qui fournissent une syntaxe pratique pour créer des chaînes mises en forme :

  var r = 2.3;
  var message = $"The area of a circle with radius {r} is {Math.PI * r * r:F3}.";
  Console.WriteLine(message);
  // Output:
  // The area of a circle with radius 2.3 is 16.619.
  

• Expressions lambda qui vous permettent de créer des fonctions anonymes :

  int[] numbers = { 2, 3, 4, 5 };
  var maximumSquare = numbers.Max(x => x * x);
  Console.WriteLine(maximumSquare);
  // Output:
  // 25
  

• Expressions de requête qui vous permettent d’utiliser des fonctionnalités de requête directement en C# :

  int[] scores = { 90, 97, 78, 68, 85 };
  IEnumerable<int> highScoresQuery =
      from score in scores
      where score > 80
      orderby score descending
      select score;
  Console.WriteLine(string.Join(" ", highScoresQuery));
  // Output:
  // 97 90 85
  

Vous pouvez utiliser une définition de corps d’expression pour fournir une définition concise pour une méthode, un constructeur, une propriété, un indexeur ou un finaliseur.

Précédence des opérateurs

Dans une expression avec plusieurs opérateurs, les opérateurs ayant une priorité plus élevée sont évalués avant les opérateurs ayant une priorité inférieure. Dans l’exemple suivant, la multiplication est effectuée en premier, car elle a une priorité plus élevée que l’ajout :

var a = 2 + 2 * 2;
Console.WriteLine(a); //  output: 6

Utilisez des parenthèses pour modifier l’ordre d’évaluation imposé par priorité d’opérateur :

var a = (2 + 2) * 2;
Console.WriteLine(a); //  output: 8

Le tableau suivant répertorie les opérateurs C# commençant par la priorité la plus élevée au plus bas. Les opérateurs de chaque ligne ont la même priorité.

Pour plus d’informations sur la précédence des combinateurs de modèles logiques, consultez la section Priorité et ordre de vérification des modèles logiques de l’article Modèles .

Associativité d’opérateur

Lorsque les opérateurs ont la même priorité, l’associativité des opérateurs détermine l’ordre dans lequel les opérations sont effectuées :

• Les opérateurs associatifs de gauche sont évalués dans l’ordre de gauche à droite. À l’exception des opérateurs d’affectation et des opérateurs null-coalescing, tous les opérateurs binaires sont associatifs de gauche. Par exemple, a + b - c est évalué en tant que (a + b) - c.
• Les opérateurs associatifs de droite sont évalués dans l’ordre de droite à gauche. Les opérateurs d’assignation, les opérateurs de fusion null, les lambdas et l’opérateur ?:conditionnel sont associatifs de droite. Par exemple, x = y = z est évalué en tant que x = (y = z).

Utilisez des parenthèses pour modifier l’ordre d’évaluation imposé par l’associativité de l’opérateur :

int a = 13 / 5 / 2;
int b = 13 / (5 / 2);
Console.WriteLine($"a = {a}, b = {b}");  // output: a = 1, b = 6

Évaluation de l’opérande

Non liés à la priorité des opérateurs et à l’associativité, les opérandes d’une expression sont évalués de gauche à droite. Les exemples suivants illustrent l’ordre dans lequel les opérateurs et opérandes sont évalués :

En règle générale, tous les opérandes d’opérateur sont évalués. Toutefois, certains opérateurs évaluent les opérandes de manière conditionnelle. Autrement dit, la valeur de l’opérande le plus à gauche d’un tel opérateur définit si (ou qui) d’autres opérandes doivent être évalués. Ces opérateurs sont les opérateurs AND () et OR (&&||) logiques conditionnels, les opérateurs ?? de fusion null et??=, les opérateurs ?. conditionnels null et ?[], et l’opérateur ?:conditionnel . Pour plus d’informations, consultez la description de chaque opérateur.

Spécification du langage C#

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

• Expressions
• Opérateurs

Voir aussi

• Surcharge des opérateurs
• Arbres d'expression