Opérateurs et expressions c# (référence C#)C# operators and expressions (C# reference)

C# fournit un certain nombre d’opérateurs.C# provides a number of operators. Un grand nombre 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.Many of them are supported by the built-in types and allow you to perform basic operations with values of those types. Ces opérateurs incluent les groupes suivants :Those operators include the following groups:

En général, 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.Typically, you can overload those operators, that is, specify the operator behavior for the operands of a user-defined type.

Les expressions C# les plus simples sont des littéraux (par exemple, des nombres entiers et réels ) et des noms de variables.The simplest C# expressions are literals (for example, integer and real numbers) and names of variables. Vous pouvez les combiner dans des expressions complexes à l’aide d’opérateurs.You can combine them into complex expressions by using operators. La priorité et l' associativité des opérateurs déterminent l’ordre dans lequel les opérations dans une expression sont exécutées.Operator precedence and associativity determine the order in which the operations in an expression are performed. Vous pouvez utiliser des parenthèses pour changer l’ordre d’évaluation imposé par la priorité et l’associativité de l’opérateur.You can use parentheses to change the order of evaluation imposed by operator precedence and associativity.

Dans le code suivant, des exemples d’expressions se trouvent dans la partie droite des affectations :In the following code, examples of expressions are at the right-hand side of assignments:

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.Typically, an expression produces a result and can be included in another expression. Un void appel de méthode est un exemple d’expression qui ne produit pas de résultat.A void method call is an example of an expression that doesn't produce a result. Il ne peut être utilisé qu’en tant qu' instruction, comme le montre l’exemple suivant :It can be used only as a statement, as the following example shows:

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

Voici d’autres genres d’expressions fournis par C# :Here are some other kinds of expressions that C# provides:

  • Expressions de chaîne interpolées qui fournissent une syntaxe pratique pour créer des chaînes mises en forme :Interpolated string expressions that provide convenient syntax to create formatted strings:

    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 :Lambda expressions that allow you to create anonymous functions:

    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 directement des fonctionnalités de requête en C# :Query expressions that allow you to use query capabilities directly in 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 d’une méthode, d’un constructeur, d’une propriété, d’un indexeur ou d’un finaliseur.You can use an expression body definition to provide a concise definition for a method, constructor, property, indexer, or finalizer.

Précédence des opérateursOperator precedence

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.In an expression with multiple operators, the operators with higher precedence are evaluated before the operators with lower precedence. Dans l’exemple suivant, la multiplication est effectuée en premier, car elle a une priorité plus élevée que l’addition :In the following example, the multiplication is performed first because it has higher precedence than 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 :Use parentheses to change the order of evaluation imposed by operator precedence:

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.The following table lists the C# operators starting with the highest precedence to the lowest. Les opérateurs dans chaque ligne sont de priorité égale.The operators within each row have the same precedence.

OpérateursOperators Catégorie ou nomCategory or name
x. y, f (x), a[i], x?.y , x?[y] , x + +, x--, x !, New, typeof, coché, désactivé, default, nameof, Delegate, sizeof, stackalloc, x->yx.y, f(x), a[i], x?.y, x?[y], x++, x--, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x->y PrincipalPrimary
+ x, -x, ! x, ~ x, + + x, --x, ^ x, (T) x, await, &x, * x, true et false+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true and false UnaireUnary
x.. yx..y PlageRange
switchswitch Expression switchswitch expression
withwith Expression withwith expression
x * y, x / y, x % yx * y, x / y, x % y MultiplicatifMultiplicative
x + y, x – yx + y, x – y AdditiveAdditive
x << y, x >> yx << y, x >> y MajShift
x < y, x > y, x <= y, x > = y, est, commex < y, x > y, x <= y, x >= y, is, as Relations et test de typeRelational and type-testing
x = = y, x ! = yx == y, x != y ÉgalitéEquality
x & y Logique booléen AND ou logique bitwise ANDBoolean logical AND or bitwise logical AND
x ^ y Logique booléen XOR ou logique bitwise XORBoolean logical XOR or bitwise logical XOR
x | y Logique booléen OR ou logique bitwise ORBoolean logical OR or bitwise logical OR
x && yx && y AND conditionnelConditional AND
x || yx || y OR conditionnelConditional OR
x ?? yx ?? y Opérateur de fusion de NullNull-coalescing operator
c ? t : fc ? t : f Opérateur conditionnelConditional operator
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, x -= y, x *= y, x /= y, x %= y, x &= y, x |= y, x ^= y, x <<= y, x >>= y, x ??= y, => Affectation et déclaration lambdaAssignment and lambda declaration

Associativité des opérateursOperator associativity

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 :When operators have the same precedence, associativity of the operators determines the order in which the operations are performed:

  • Les opérateurs associatifs sur leur gauche sont évalués dans l’ordre, de gauche à droite.Left-associative operators are evaluated in order from left to right. À l’exception des opérateurs d' assignation et des opérateurs de fusion Null, tous les opérateurs binaires sont associatifs à gauche.Except for the assignment operators and the null-coalescing operators, all binary operators are left-associative. Par exemple, a + b - c est évalué comme étant (a + b) - c.For example, a + b - c is evaluated as (a + b) - c.
  • Les opérateurs associatifs sur leur droite sont évalués dans l’ordre, de droite à gauche.Right-associative operators are evaluated in order from right to left. Les opérateurs d’assignation, les opérateurs de fusion Null et l' opérateur ?: conditionnel sont associatifs à droite.The assignment operators, the null-coalescing operators, and the conditional operator ?: are right-associative. Par exemple, x = y = z est évalué comme étant x = (y = z).For example, x = y = z is evaluated as x = (y = z).

Utilisez des parenthèses pour changer l’ordre d’évaluation imposé par l’associativité des opérateurs :Use parentheses to change the order of evaluation imposed by operator associativity:

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

Évaluation des opérandesOperand evaluation

Sans rapport avec la priorité et l’associativité des opérateurs, les opérandes dans une expression sont évalués de gauche à droite.Unrelated to operator precedence and associativity, operands in an expression are evaluated from left to right. Les exemples suivants illustrent l’ordre dans lequel les opérateurs et les opérandes sont évalués :The following examples demonstrate the order in which operators and operands are evaluated:

ExpressionExpression Ordre d’évaluationOrder of evaluation
a + b a, b, +a, b, +
a + b * c a, b, c, *, +a, b, c, *, +
a / b + c * d a, b, /, c, d, *, +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.Typically, all operator operands are evaluated. Toutefois, certains opérateurs évaluent les opérandes de manière conditionnelle.However, some operators evaluate operands conditionally. 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.That is, the value of the leftmost operand of such an operator defines if (or which) other operands should be evaluated. Ces opérateurs sont les opérateurs logiques and ( && ) et or || () conditionnels, les opérateurs de fusion Null ?? et ??= , les opérateurs conditionnels null ?. et ?[] , ainsi que l' opérateur ?: conditionnel .These operators are the conditional logical AND (&&) and OR (||) operators, the null-coalescing operators ?? and ??=, the null-conditional operators ?. and ?[], and the conditional operator ?:. Pour plus d’informations, consultez la description de chaque opérateur.For more information, see the description of each operator.

spécification du langage C#C# language specification

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :For more information, see the following sections of the C# language specification:

Voir aussiSee also