> ## 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# Ref Local Variable
A `ref` local variable is a local variable that acts as a direct alias to another variable's memory location rather than storing a discrete copy of its value. Any read or write operation performed on the `ref` local is executed directly against the underlying memory address of the aliased variable.
## Syntax and Initialization
To declare a `ref` local, the `ref` keyword must precede both the type declaration and the initialization expression.
```csharp theme={"dark"}
int originalVariable = 42;
// 'refLocal' is now an alias for 'originalVariable'
ref int refLocal = ref originalVariable;
// Mutating the ref local mutates the original memory location
refLocal = 100;
// originalVariable is now 100
```
## Reference Reassignment (C# 7.3+)
By default, assigning a value to a `ref` local overwrites the value at the referenced memory location. However, using the `ref` keyword during assignment allows the `ref` local to be repointed to an entirely different memory location.
```csharp theme={"dark"}
int valueA = 10;
int valueB = 20;
ref int alias = ref valueA; // Points to valueA
// Standard assignment: Mutates the value at the current memory location (valueA becomes 50)
alias = 50;
// Reference reassignment: Changes the memory location 'alias' points to
alias = ref valueB;
// Mutates valueB
alias = 99;
```
## `ref readonly` Locals
You can enforce immutability on the aliased memory location by declaring the local as `ref readonly`. This permits reading from the memory address while preventing any modifications through the alias.
```csharp theme={"dark"}
int mutableValue = 5;
ref readonly int readOnlyAlias = ref mutableValue;
// Valid: Reading the value
int copy = readOnlyAlias;
// Compiler Error: Cannot assign to a readonly ref local
// readOnlyAlias = 10;
```
## Technical Constraints and Rules
1. **Mandatory Initialization:** A `ref` local must be initialized at the time of declaration. It cannot be declared uninitialized and assigned later.
```csharp theme={"dark"}
```
// Compiler Error: A ref local must be initialized
// ref int invalidRef;
```
2. **Type Matching:** The type of the `ref` local must strictly match the type of the variable it aliases. Implicit conversions are not permitted because the alias must map exactly to the underlying memory layout.
3. **Escape Analysis (Lifetime Rules):** The C# compiler enforces strict lifetime rules (safe-to-escape rules) to prevent dangling pointers. A `ref` local cannot refer to a variable that has a narrower scope or shorter lifetime than the `ref` local itself.
4. **Property Restrictions:** A `ref` local cannot alias a property or an indexer that does not return by reference, because properties are methods under the hood and do not inherently represent a stable memory location.
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
```
