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

2025-06-13

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

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.

Cette opération est appelée affectation de valeur: la valeur est affectée.

À compter de C# 14, le côté gauche d’une affectation de valeur peut inclure une expression de membre conditionnel Null, telle que ?. ou ?[]. Si le côté gauche est null, l’expression côté droit n’est pas évalué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.

Une affectation ref signifie qu’une variable de référence a un autre référentiel. Il ne fait plus référence à son précédent référent. L’utilisation de ref = sur un paramètre ref signifie que le paramètre ne fait plus référence à son argument. Toutes les actions qui modifient l’état de l’objet après sa réaffectation effectuent ces modifications au nouvel élément. Par exemple, considérez la méthode suivante :

private static void RefReassignAndModify(scoped ref string s)
{
    string sLocal = "Hello";
    Console.WriteLine(sLocal);  // Output: Hello

    s = ref sLocal;
    s = "World";
    Console.WriteLine(s);  // Output: World

L’utilisation suivante montre que l’affectation au paramètre s n’est pas visible après l’appel de méthode, car s a été ref réaffectée pour faire référence à sLocal avant la modification de la chaîne :

string msg = "Hi";
RefReassignAndModify(ref msg);
Console.WriteLine(msg); // Output: Hi!

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.

Les opérateurs arithmétiques, logiques booléens, et logiques au niveau du bit et de décalage prennent tous en charge l’affectation composée.

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 sur les opérateurs ?? et ??=.

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.

Si un type défini par l’utilisateur surcharge un opérateur opbinaire, l’opérateur op= , s’il existe, est également implicitement surchargé. À compter de C# 14, un type défini par l’utilisateur peut surcharger explicitement les opérateurs d’affectation composée (op=) pour fournir une implémentation plus efficace. En règle générale, un type surcharge ces opérateurs, car la valeur peut être mise à jour en place, plutôt que d’allouer une nouvelle instance pour contenir le résultat de l’opération binaire. Si un type ne fournit pas de surcharge explicite, le compilateur génère la surcharge implicite.

spécification du langage C#

Pour plus d’informations, consultez la section Opérateurs d’affectation de la spécification du langage C# et la spécification de fonctionnalité d’affectation composée définie par l’utilisateur .

Partager via