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

  • Article

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, c’est-à-dire 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 les littéraux (par exemple, les nombres entiers et réels ) et les noms des 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 sont exécutées dans une expressions. 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, 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];

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 appel de méthode void est un exemple d’expression qui ne produit pas de résultat. Elle ne peut être utilisée qu’en tant qu’instruction, comme le montre l’exemple suivant :

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

Voici d’autres types d’expressions que C# fournit :

  • Expressions de chaîne interpolée 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 les 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, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x->y Principal
+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true and false Unaire
x..y Plage
switch, avec expressions switch et with
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, is, as 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, => 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’assignation et de l’opérateur de fusion Null, tous les opérateurs binaires sont associatifs sur leur 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’assignation, l’opérateur de fusion Null, lambda et l’opérateur conditionnel?: sont associatifs sur leur 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 opérateur de ce type définit si les autres opérandes doivent être évalués. Ces opérateurs sont les opérateurs conditionnels logiques AND (&&) et OR (||), l’opérateur 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