Opérateurs d’affectation (référence C#)

  • Article

L’opérateur d’affectation = affecte la valeur de son opérande droit à une variable, une propriété ou un élément indexeur donné par son opérande gauche. Le résultat d’une expression d’assignation est la valeur assignée à l’opérande de gauche. L’opérande de droite doit être du même type que l’opérande de gauche, ou implicitement convertible vers le type de l’opérande de gauche.

L’opérateur d’affectation = est associatif droit, c’est-à-dire une expression du formulaire

a = b = c

est évaluée comme étant

a = (b = c)

L’exemple suivant illustre l’utilisation de l’opérateur d’assignation avec une variable locale, une propriété et un élément d’indexeur comme opérande de gauche :

List<double> numbers = [1.0, 2.0, 3.0];

Console.WriteLine(numbers.Capacity);
numbers.Capacity = 100;
Console.WriteLine(numbers.Capacity);
// Output:
// 4
// 100

int newFirstElement;
double originalFirstElement = numbers[0];
newFirstElement = 5;
numbers[0] = newFirstElement;
Console.WriteLine(originalFirstElement);
Console.WriteLine(numbers[0]);
// Output:
// 1
// 5

L’opérande gauche d’une affectation reçoit la valeur de l’opérande droit. Lorsque les opérandes sont de types valeur, l’affectation copie le contenu de l’opérande droit. Lorsque les opérandes sont de types de référence, l’affectation copie la référence à l’objet.

Il s’agit de l’affectation de valeur : la valeur est affectée.

affectation ref

Affectation ref= ref fait de son opérande de gauche un alias de l’opérande de droite, comme le montre l’exemple suivant :

void Display(double[] s) => Console.WriteLine(string.Join(" ", s));

double[] arr = { 0.0, 0.0, 0.0 };
Display(arr);

ref double arrayElement = ref arr[0];
arrayElement = 3.0;
Display(arr);

arrayElement = ref arr[arr.Length - 1];
arrayElement = 5.0;
Display(arr);
// Output:
// 0 0 0
// 3 0 0
// 3 0 5

Dans l’exemple précédent, la variable de référence localearrayElement est initialisée en tant qu’alias au premier élément du tableau. Ensuite, elle est ref réassignée pour faire référence au dernier élément de tableau. Comme il s’agit d’un alias, lorsque vous mettez à jour sa valeur avec un opérateur d’affectation ordinaire =, l’élément de tableau correspondant est également mis à jour.

L’opérande de gauche de l’affectation ref peut être une variable de référence locale, un ref champ et un paramètre de la méthode ref, out ou in. Les deux opérandes doivent être du même type.

Assignation composée

Pour un opérateur binaire op, une expression d’assignation composée du formulaire

x op= y

équivaut à :

x = x op y

sauf que x n’est évalué qu’une seule fois.

L’assignation composée est prise en charge par les opérateurs arithmétiques, logiques booléens et logiques au niveau du bit et du décalage.

Attribution de fusion Null

Vous pouvez utiliser l’opérateur d’affectation null-coalescing ??= pour affecter la valeur de l’opérande droit à l’opérande gauche uniquement si l’opérande gauche a la valeur null. Pour plus d’informations, consultez l’article ?? et ?? = opérateurs.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur ne peut pas surcharger l’opérateur d’affectation. Toutefois, il peut définir une conversion implicite vers un autre type. Ainsi, la valeur d’un type défini par l’utilisateur peut être assignée à une variable, une propriété ou un élément d’indexeur d’un autre type. Pour plus d’informations, consultez Opérateurs de conversion définie par l’utilisateur.

Un type défini par l’utilisateur ne peut pas surcharger explicitement un opérateur d’assignation composée. Toutefois, si un type défini par l’utilisateur surcharge un opérateur binaire op, l’opérateur op=, s’il existe, est également implicitement surchargé.

spécification du langage C#

Pour plus d’informations, voir la section Opérateurs d’assignation de la spécification du langage C#.

Voir aussi