Opérateurs C#C# Operators

C# fournit de nombreux opérateurs, qui sont des symboles spécifiant quelles opérations (mathématiques, indexation, appel de fonction, etc.) effectuer dans une expression.C# provides many operators, which are symbols that specify which operations (math, indexing, function call, etc.) to perform in an expression. Vous pouvez surcharger de nombreux opérateurs pour modifier leur signification quand ils sont appliqués à un type défini par l’utilisateur.You can overload many operators to change their meaning when applied to a user-defined type.

Les opérations sur les types intégraux (comme ==, !=, <, >, & ou |) sont en général autorisées sur les types énumération (enum).Operations on integral types (such as ==, !=, <, >, &, |) are generally allowed on enumeration (enum) types.

Les sections ci-dessous listent les opérateurs C# de la priorité la plus élevée à la plus basse.The sections below list the C# operators starting with the highest precedence to the lowest. Les opérateurs inclus dans chaque section partagent le même niveau de priorité.The operators within each section share the same precedence level.

Opérateurs principauxPrimary Operators

Ce sont les opérateurs dont la priorité est la plus élevée.These are the highest precedence operators.

x.y : accès au membre.x.y – member access.

x?.y : accès au membre conditionnel Null.x?.y – null conditional member access. Retourne null si l’opérande de gauche prend la valeur null.Returns null if the left-hand operand evaluates to null.

x?[y] : accès à l’index conditionnel Null.x?[y] - null conditional index access. Retourne null si l’opérande de gauche prend la valeur null.Returns null if the left-hand operand evaluates to null.

f(x) : appel de fonction.f(x) – function invocation.

a[x] : indexation de l’objet d’agrégation.a[x] – aggregate object indexing.

x++ : incrément suffixé.x++ – postfix increment. Retourne la valeur de x et met à jour l'emplacement de stockage avec la valeur de x augmentée de un (ajoute généralement l'entier 1).Returns the value of x and then updates the storage location with the value of x that is one greater (typically adds the integer 1).

x-- : décrément suffixé.x-- – postfix decrement. Retourne la valeur de x et met à jour l'emplacement de stockage avec la valeur de x diminuée de un (soustrait généralement l'entier 1).Returns the value of x and then updates the storage location with the value of x that is one less (typically subtracts the integer 1).

new : instanciation de type.new – type instantiation.

typeof : retourne l’objet Type qui représente l’opérande.typeof – returns the Type object representing the operand.

checked : active le contrôle de dépassement de capacité pour les opérations sur les entiers.checked – enables overflow checking for integer operations.

unchecked : désactive le contrôle de dépassement de capacité pour les opérations sur les entiers.unchecked – disables overflow checking for integer operations. Il s'agit du comportement de compilateur par défaut.This is the default compiler behavior.

default(T) – produit la valeur par défaut du type T.default(T) – produces the default value of type T.

delegate : déclare et retourne une instance de délégué.delegate – declares and returns a delegate instance.

sizeof : retourne la taille en octets de l’opérande du type.sizeof – returns the size in bytes of the type operand.

-> : déréférencement de pointeur associé à l’accès au membre.-> – pointer dereferencing combined with member access.

Opérateurs unairesUnary Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

+x : retourne la valeur de x.+x – returns the value of x.

-x : négation numérique.-x – numeric negation.

!x : négation logique.!x – logical negation.

~x : complément au niveau du bit.~x – bitwise complement.

++x : incrément préfixé.++x – prefix increment. Retourne la valeur de x après avoir mis à jour l'emplacement de stockage avec la valeur de x augmentée de un (ajoute généralement l'entier 1).Returns the value of x after updating the storage location with the value of x that is one greater (typically adds the integer 1).

--x : décrément préfixé.--x – prefix decrement. Retourne la valeur de x après avoir mis à jour l’emplacement de stockage avec la valeur de x diminuée d’une unité (soustrait généralement l’entier 1).Returns the value of x after updating the storage location with the value of x that is one less (typically subtracts the integer 1).

(T)x : cast de type.(T)x – type casting.

await : attend un Task.await – awaits a Task.

&x : adresse de.&x – address of.

*x : déréférencement.*x – dereferencing.

Opérateurs multiplicatifsMultiplicative Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

x * y : multiplication.x * y – multiplication.

x / y : division.x / y – division. Si les opérandes sont des entiers, le résultat est un entier tronqué vers zéro (par exemple, -7 / 2 is -3).If the operands are integers, the result is an integer truncated toward zero (for example, -7 / 2 is -3).

x % y : reste.x % y – remainder. Si les opérandes sont des entiers, cet opérateur renvoie le reste de la division de x par y.If the operands are integers, this returns the remainder of dividing x by y. Si q = x / y et r = x % y, alors x = q * y + r.If q = x / y and r = x % y, then x = q * y + r.

Opérateurs additifsAdditive Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

x + y : addition.x + y – addition.

x – y : soustraction.x – y – subtraction.

Opérateurs de décalageShift Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

x << y : décalage des bits vers la gauche et remplissage avec zéro à droite.x << y – shift bits left and fill with zero on the right.

x >> y : décalage des bits vers la droite.x >> y – shift bits right. Si l'opérande de gauche est int ou long, alors les bits de gauche sont remplis avec le bit de signe.If the left operand is int or long, then left bits are filled with the sign bit. Si l'opérande de gauche est uint ou ulong, alors les bits de gauche sont remplis avec zéro.If the left operand is uint or ulong, then left bits are filled with zero.

Opérateurs relationnels et de test de typeRelational and Type-testing Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

x < y : inférieur à (true si x est inférieur à y).x < y – less than (true if x is less than y).

x > y : supérieur à (true si x est supérieur à y).x > y – greater than (true if x is greater than y).

x <= y : supérieur ou égal à.x <= y – less than or equal to.

x >= y : supérieur ou égal à.x >= y – greater than or equal to.

is : compatibilité du type.is – type compatibility. Retourne true si l’opérande de gauche évalué peut être converti en type spécifié dans l’opérande de droite (type statique).Returns true if the evaluated left operand can be cast to the type specified in the right operand (a static type).

as : conversion de type.as – type conversion. Retourne l'opérande de gauche converti en type spécifié par l'opérande de droite (type statique), mais as retourne null(T)x lèverait une exception.Returns the left operand cast to the type specified by the right operand (a static type), but as returns null where (T)x would throw an exception.

Opérateurs d'égalitéEquality Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

x == y : égalité.x == y – equality. Par défaut, pour les types de référence autres que string, cet opérateur retourne l'égalité de référence (test d'identité).By default, for reference types other than string, this returns reference equality (identity test). Toutefois, des types peuvent surcharger ==, donc si votre objectif est de tester l'identité, il est préférable d'utiliser la méthode ReferenceEquals sur object.However, types can overload ==, so if your intent is to test identity, it is best to use the ReferenceEquals method on object.

x != y : différent.x != y – not equal. Consultez le commentaire sur ==.See comment for ==. Si un type surcharge ==, alors il doit surcharger !=.If a type overloads ==, then it must overload !=.

Opérateur AND logiqueLogical AND Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

x & y : ET logique ou au niveau du bit.x & y – logical or bitwise AND. Vous pouvez l'utiliser généralement avec des types entiers et des types enum.You can generally use this with integer types and enum types.

Opérateur XOR logiqueLogical XOR Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

x ^ y : XOR logique ou au niveau du bit.x ^ y – logical or bitwise XOR. Vous pouvez l'utiliser généralement avec des types entiers et des types enum.You can generally use this with integer types and enum types.

Opérateur OR logiqueLogical OR Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

x | y : OU logique ou au niveau du bit.x | y – logical or bitwise OR. Vous pouvez l'utiliser généralement avec des types entiers et des types enum.You can generally use this with integer types and enum types.

Opérateur AND conditionnelConditional AND Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

x && y : ET logique.x && y – logical AND. Si le premier opérande prend la valeur false, C# n’évalue pas le second opérande.If the first operand evaluates to false, then C# does not evaluate the second operand.

Opérateur OR conditionnelConditional OR Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

x || y : OU logique.x || y – logical OR. Si le premier opérande prend la valeur true, C# n’évalue pas le second opérande.If the first operand evaluates to true, then C# does not evaluate the second operand.

Opérateur de fusion de NullNull-coalescing Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

x ?? y : retourne x si non null ; dans le cas contraire, retourne y.x ?? y – returns x if it is non-null; otherwise, returns y.

Opérateur conditionnelConditional Operator

Cet opérateur a une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.This operator has higher precedence than the next section and lower precedence than the previous section.

t ? x : y : si le test t prend la valeur true, alors évalue et retourne x ; sinon, évalue et retourne y.t ? x : y – if test t evaluates to true, then evaluate and return x; otherwise, evaluate and return y.

Opérateurs d'assignation et lambdaAssignment and Lambda Operators

Ces opérateurs ont une priorité supérieure à celle de la section suivante et une priorité inférieure à celle de la section précédente.These operators have higher precedence than the next section and lower precedence than the previous section.

x = y : affectation.x = y – assignment.

x += y : incrément.x += y – increment. Additionne la valeur de y à la valeur de x, stocke le résultat dans x et retourne la nouvelle valeur.Add the value of y to the value of x, store the result in x, and return the new value. Si x désigne un event, alors y doit être une fonction appropriée que C# ajoute en tant que gestionnaire d'événements.If x designates an event, then y must be an appropriate function that C# adds as an event handler.

x -= y : décrément.x -= y – decrement. Soustrait la valeur de y de la valeur de x, stocke le résultat dans x et retourne la nouvelle valeur.Subtract the value of y from the value of x, store the result in x, and return the new value. Si x désigne un event, alors y doit être une fonction appropriée que C# supprime en tant que gestionnaire d'événements.If x designates an event, then y must be an appropriate function that C# removes as an event handler

x *= y : affectation de multiplication.x *= y – multiplication assignment. Multiplie la valeur de y par la valeur de x, stocke le résultat dans x et retourne la nouvelle valeur.Multiply the value of y to the value of x, store the result in x, and return the new value.

x /= y : affectation de division.x /= y – division assignment. Divise la valeur de x par la valeur de y, stocke le résultat dans x et retourne la nouvelle valeur.Divide the value of x by the value of y, store the result in x, and return the new value.

x %= y : assignation de reste.x %= y – remainder assignment. Divise la valeur de x par la valeur de y, stocke le reste dans x et retourne la nouvelle valeur.Divide the value of x by the value of y, store the remainder in x, and return the new value.

x &= y : affectation ET.x &= y – AND assignment. Assigne l'opérateur AND à la valeur de y et la valeur de x, stocke le résultat dans x et retourne la nouvelle valeur.AND the value of y with the value of x, store the result in x, and return the new value.

x |= y : affectation OU.x |= y – OR assignment. Assigne l'opérateur OR à la valeur de y et la valeur de x, stocke le résultat dans x et retourne la nouvelle valeur.OR the value of y with the value of x, store the result in x, and return the new value.

x ^= y : affectation XOR.x ^= y – XOR assignment. Assigne l'opérateur XOR à la valeur de y et la valeur de x, stocke le résultat dans x et retourne la nouvelle valeur.XOR the value of y with the value of x, store the result in x, and return the new value.

x <<= y : affectation de décalage vers la gauche.x <<= y – left-shift assignment. Décale la valeur de x vers la gauche de y places, stocke le résultat dans x et retourne la nouvelle valeur.Shift the value of x left by y places, store the result in x, and return the new value.

x >>= y : affectation de décalage vers la droite.x >>= y – right-shift assignment. Décale la valeur de x vers la droite de y places, stocke le résultat dans x et retourne la nouvelle valeur.Shift the value of x right by y places, store the result in x, and return the new value.

=> : déclaration lambda.=> – lambda declaration.

Dépassement arithmétiqueArithmetic Overflow

Les opérateurs arithmétiques (+, -, * et /) peuvent produire des résultats qui sont en dehors de la plage de valeurs possibles pour le type numérique concerné.The arithmetic operators (+, -, *, /) can produce results that are outside the range of possible values for the numeric type involved. Reportez-vous à la section d'un opérateur particulier pour obtenir plus d'informations, mais en règle générale, les points suivants s'appliquent :You should refer to the section on a particular operator for details, but in general:

  • Le dépassement arithmétique d'un entier lève soit une exception OverflowException ou ignore les bits les plus significatifs du résultat.Integer arithmetic overflow either throws an OverflowException or discards the most significant bits of the result. La division d'un entier par zéro lève toujours une exception DivideByZeroException.Integer division by zero always throws a DivideByZeroException.

    En cas de dépassement d’un entier, ce qui se produit dépend du contexte d’exécution, lequel peut être checked ou unchecked.When integer overflow occurs, what happens depends on the execution context, which can be checked or unchecked. Dans un contexte checked, une exception OverflowException est levée.In a checked context, an OverflowException is thrown. Dans un contexte unchecked, les bits les plus significatifs du résultat sont ignorés et l'exécution se poursuit.In an unchecked context, the most significant bits of the result are discarded and execution continues. Ainsi, C# vous donne la possibilité de traiter ou d'ignorer le dépassement.Thus, C# gives you the choice of handling or ignoring overflow. Par défaut, les opérations arithmétiques se produisent dans un contexte unchecked.By default, arithmetic operations occur in an unchecked context.

    En plus des opérations arithmétiques, des casts entre types intégraux peuvent générer un dépassement (par exemple en cas de conversion de type de long en int). Ils sont sujets à une exécution checked ou unchecked.In addition to the arithmetic operations, integral-type to integral-type casts can cause overflow (such as when you cast a long to an int), and are subject to checked or unchecked execution. En revanche, les opérateurs de bits et les opérateurs de décalage ne génèrent jamais de dépassement.However, bitwise operators and shift operators never cause overflow.

  • Le dépassement arithmétique ou la division par zéro d'une virgule flottante ne lèvent jamais d'exception, car les types à virgule flottante se basent sur IEEE 754 et peuvent représenter l'infini et NaN (n'est pas un nombre).Floating-point arithmetic overflow or division by zero never throws an exception, because floating-point types are based on IEEE 754 and so have provisions for representing infinity and NaN (Not a Number).

  • Le dépassement arithmétique d’un nombre décimal lève toujours une exception OverflowException.Decimal arithmetic overflow always throws an OverflowException. La division d'un nombre décimal par zéro lève toujours une exception DivideByZeroException.Decimal division by zero always throws a DivideByZeroException.

Voir aussiSee Also

Référence C#C# Reference
Guide de programmation C#C# Programming Guide
Opérateurs surchargeables C#C# Overloadable Operators
Mots clés C#C# Keywords