> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# Assignment
The `=` operator is the simple assignment operator in C#. It assigns the value of the right-hand expression to the variable, property, indexer element, or tuple element specified by the left-hand operand. During execution, the operands of an assignment are evaluated strictly from **left to right**: the left-hand operand is evaluated first to establish the target memory location, and then the right-hand expression is evaluated to produce the value to be stored.
```csharp theme={"dark"}
int rightOperand = 10;
int leftOperand = rightOperand;
```
## Evaluation and Associativity
An assignment is an *expression* that yields the value assigned to the left-hand operand. Because it yields a value, multiple assignment operations can be chained together. The `=` operator is **right-associative**, meaning chained assignments are grouped and evaluated from right to left.
```csharp theme={"dark"}
int a, b, c;
a = b = c = 5;
// Grouped as: a = (b = (c = 5))
```
## Type Constraints
For an assignment to be valid at compile time, the type of the right-hand expression must be identical to, or **implicitly convertible** to, the type of the left-hand target. If no implicit conversion exists, the compiler throws a `CS0029` error, necessitating an explicit cast.
## Memory Semantics
The mechanical behavior of the `=` operator depends strictly on whether the operands are value types or reference types:
* **Value Types (`struct`, `enum`, primitives):** The operator performs a shallow, bitwise copy of the actual data payload from the right operand to the left operand's memory location. The two variables remain entirely independent.
* **Reference Types (`class`, `interface`, `delegate`):** The operator copies the memory address (the reference pointer), not the underlying object payload. After assignment, both the left and right operands point to the exact same object instance on the managed heap, or both evaluate to `null` if the right-hand expression is a null reference.
## Deconstruction
Introduced in C# 7.0, the `=` operator supports deconstruction. This allows a single operation to unpack a tuple or an object (via a `Deconstruct` method) into multiple distinct variables simultaneously. This syntax is categorized into two distinct operations depending on whether the variables are pre-existing or newly declared:
```csharp theme={"dark"}
// Deconstruction assignment (unpacking into previously declared variables)
int x, y;
(x, y) = (1, 2);
// Deconstruction declaration (declaring new variables inline)
(int alpha, int beta) = (3, 4);
```
## Ref Assignment (`= ref`)
Introduced in C# 7.3, the `ref` assignment operator alters the reference itself rather than the value at the reference's destination. It binds a `ref` local variable to a new memory location.
```csharp theme={"dark"}
int variableA = 10;
int variableB = 20;
ref int pointer1 = ref variableA;
pointer1 = ref variableB; // Rebinds pointer1 to the memory location of variableB
```
## Overloadability
The simple assignment operator `=` **cannot** be explicitly overloaded in C#. However, its behavior across different types can be indirectly modified by defining user-defined implicit conversion operators (`public static implicit operator`) on a `class` or `struct`, which the compiler will automatically invoke during the assignment process.
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
