Assignment operators (C# reference)
The assignment operator = assigns the value of its right-hand operand to a variable, a property, or an indexer element given by its left-hand operand. The result of an assignment expression is the value assigned to the left-hand operand. The type of the right-hand operand must be the same as the type of the left-hand operand or implicitly convertible to it.
The assignment operator = is right-associative, that is, an expression of the form
a = b = c
Is evaluated as
a = (b = c)
The following example demonstrates the usage of the assignment operator with a local variable, a property, and an indexer element as its left-hand operand:
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
The left-hand operand of an assignment receives the value of the right-hand operand. When the operands are of value types, assignment copies the contents of the right-hand operand. When the operands are of reference types, assignment copies the reference to the object.
This operation is called value assignment: the value is assigned.
ref assignment
Ref assignment = ref makes its left-hand operand an alias to the right-hand operand, as the following example demonstrates:
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
In the preceding example, the local reference variable arrayElement is initialized as an alias to the first array element. Then, it's ref reassigned to refer to the last array element. As it's an alias, when you update its value with an ordinary assignment operator =, the corresponding array element is also updated.
The left-hand operand of ref assignment can be a local reference variable, a ref field, and a ref, out, or in method parameter. Both operands must be of the same type.
A ref assignment means that a reference variable has a different referrent. It's no longer referring to its previous referrent. Using ref = on a ref parameter means the parameter no longer refers to its argument. Any actions that modify the state of the object after ref reassigning it make those modifications to the new item. For example, consider the following method:
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
The following usage shows that the assignment to the parameter s isn't visible after the method call because s was ref reassigned to refer to sLocal before the string was modified:
string msg = "Hi";
RefReassignAndModify(ref msg);
Console.WriteLine(msg); // Output: Hi!
Compound assignment
For a binary operator op, a compound assignment expression of the form
x op= y
Is equivalent to
x = x op y
Except that x is only evaluated once.
The arithmetic, Boolean logical, and bitwise logical and shift operators all support compount assignment.
Null-coalescing assignment
You can use the null-coalescing assignment operator ??= to assign the value of its right-hand operand to its left-hand operand only if the left-hand operand evaluates to null. For more information, see the ?? and ??= operators article.
Operator overloadability
A user-defined type can't overload the assignment operator. However, a user-defined type can define an implicit conversion to another type. That way, the value of a user-defined type can be assigned to a variable, a property, or an indexer element of another type. For more information, see User-defined conversion operators.
A user-defined type can't explicitly overload a compound assignment operator. However, if a user-defined type overloads a binary operator op, the op= operator, if it exists, is also implicitly overloaded.
C# language specification
For more information, see the Assignment operators section of the C# language specification.
