Opérateurs et expressions C# (référence C#)

  • Article
  • 5 minutes de lecture

C# fournit un certain nombre d’opérateurs. Beaucoup 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 :

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é et l’associativité de l’opérateur déterminent l’ordre dans lequel les opérations d’une expression sont effectuées. Vous pouvez utiliser des parenthèses pour changer l’ordre d’évaluation imposé par la priorité et l’associativité de l’opérateur.

Dans le code suivant, les 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];

var numbers = new List<int>(new[] { 1, 2, 3 });
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 quelques 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#:

    var scores = new[] { 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.

Priorité des opérateurs

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

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

Utilisez des parenthèses pour changer l’ordre d’évaluation imposé par la précédence des opérateurs :

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

La table suivante répertorie les opérateurs C# de la priorité la plus élevée à la plus basse. Les opérateurs dans chaque ligne sont de priorité égale.

Opérateurs Catégorie ou nom
x.y, f(x), a[i], x?.y, x?[y], x++, x-,x!, new, typeof, coché, décoché,default, nameof, délégué, sizeof, stackalloc, x-y> Principal
+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true et false Unaire
x..y Plage
switch, avec switch et with expressions
x * y, x / y, x % y Multiplicatif
x + y, x – y Additive
x << y, x >> y Shift
x < y, x y, x ><= y, x >= y, est, comme Relations et test de type
x == y, x != y Égalité
x & y Logique booléen AND ou logique bitwise AND
x ^ y Logique booléen XOR ou logique bitwise XOR
x | y Logique booléen OR ou logique bitwise OR
x && y AND conditionnel
x || y OR conditionnel
x ?? y Opérateur de fusion de Null
C? t : f Opérateur conditionnel
x = y, x += y, x -= y, x *= y, x /= y, x %= y, x %= y, x &= y, x |= y, x ^= y, x <<= y, x = y, x >>= y, x ? = y, => Affectation et déclaration lambda

Associativité des opérateurs

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

  • Les opérateurs associatifs sur leur 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é comme étant (a + b) - c.
  • Les opérateurs associatifs sur leur droite sont évalués dans l’ordre, de droite à gauche. Les opérateurs d’affectation, les opérateurs de fusion null, les lambdas et l’opérateur ?:conditionnel sont associatifs de droite. Par exemple, x = y = z est évalué comme étant x = (y = z).

Utilisez des parenthèses pour changer l’ordre d’évaluation imposé par l’associativité des opérateurs :

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

Évaluation des opérandes

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

Expression Ordre d’évaluation
a + b a, b, +
a + b * c a, b, c, *, +
a / b + c * d a, b, /, c, d, *, +
a / (b + c) * d a, b, c, +, /, d, *

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# :

Voir aussi