Opérateurs d’affectation (référence C#)
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.
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, logiques bitwise et de décalage prennent tous en charge l'affectation du décompte.
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#.
