Opérateur C# (Référence C#)C# operators (C# reference)

C# fournit plusieurs opérateurs prédéfinis pris en charge par les types intégrés.C# provides a number of predefined operators supported by the built-in types. Par exemple, les opérateurs arithmétiques effectuent des opérations arithmétiques avec des opérandes de types numériques intégrés et les opérateurs logiques booléens effectuent des opérations logiques avec les opérandes bool.For example, arithmetic operators perform arithmetic operations with operands of built-in numeric types and Boolean logical operators perform logical operations with the bool operands.

Un type défini par l’utilisateur peut surcharger certains opérateurs pour définir le comportement correspondant des opérandes de ce type.A user-defined type can overload certain operators to define the corresponding behavior for the operands of that type. Pour plus d’informations, consultez l’article sur le mot clé opérateur.For more information, see the operator keyword article.

Les sections suivantes listent les opérateurs C# de la priorité la plus élevée à la plus basse.The following sections 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’indexeur de type ou d’élément de tableau conditionnel Null.x?[y] - null conditional array element or type indexer 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 méthode ou appel de délégué.f(x) – method call or delegate invocation.

un[x] : accès à l’indexeur de type ou d’élément de tableau.a[x] – array element or type indexer access.

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.

nameof : obtient le nom simple (non qualifié) d’une variable, d’un type ou d’un membre sous forme de chaîne constante.nameof - obtains the simple (unqualified) name of a variable, type, or member as a constant string.

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.

stackalloc : alloue un bloc de mémoire dans la pile.stackalloc - allocates a block of memory on the stack.

-> : indirection de pointeur associé à l’accès au membre.-> – pointer indirection combined with member access.

Les opérateurs unaires.Unary 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 d’une variable.&x – address of a variable.

*x – indirection de pointeur ou déréférencement.*x – pointer indirection, or dereference.

Opérateur true : retourne la valeur bool true pour indiquer qu’un opérande est true.true operator - returns the bool value true to indicate that an operand is definitely true.

Opérateur false : retourne la valeur bool true pour indiquer qu’un opérande est false.false operator - returns the bool value true to indicate that an operand is definitely false.

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 & yAND logique dans le cas des opérandes bool ou AND logique au niveau du bit dans le cas des opérandes de type intégral.x & ylogical AND for the bool operands or bitwise logical AND for the operands of the integral 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 ^ yXOR logique dans le cas des opérandes bool ou XOR logique au niveau du bit dans le cas des opérandes de type intégral.x ^ ylogical XOR for the bool operands or bitwise logical XOR for the operands of the integral types.

Opérateur OU 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 | yOR logique dans le cas des opérandes bool ou OR logique au niveau du bit dans le cas des opérandes de type intégral.x | ylogical OR for the bool operands or bitwise logical OR for the operands of the integral 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’affectation 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 événement, y doit être une méthode appropriée que C# ajoute en tant que gestionnaire d’événements.If x designates an event, then y must be an appropriate method 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 événement, y doit être une méthode appropriée que C# supprime en tant que gestionnaire d’événements.If x designates an event, then y must be an appropriate method 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.

Voir aussiSee also