Ref Parameter

The ref keyword in C# indicates that a value is passed or bound by reference. At the CLR level, ref utilizes a managed pointer (&) to a memory location rather than copying the value itself. This establishes an alias to the original variable, meaning any read or write operations interact directly with the original memory address.

ref Parameters

When used as a method parameter modifier, ref requires that the argument be explicitly initialized before invocation. The keyword must be present in both the method signature and the call site to enforce explicit intent.

public void MutateValue(ref int number)
{
    number += 10;
}

int myValue = 5; // Mandatory initialization
MutateValue(ref myValue); 

Value Types vs. Reference Types

• Value Types: Normally passed by copying the data to the stack or a CPU register. Passing a value type by ref passes a managed pointer to the instance, allowing direct mutation of the caller’s struct or primitive.
• Reference Types: Normally passed by copying the reference (the pointer to the heap allocation). Passing a reference type by ref passes a pointer to the reference (a pointer-to-pointer). This allows the method to reassign the caller’s variable to point to a completely different object on the managed heap.

public void ReassignReference(ref List<string> list)
{
    // Reassigns the caller's reference to a new heap allocation
    list = new List<string>(); 
}

Memory Mechanics

Passing a value type by value does not allocate heap memory; it simply copies the value to the stack or a register. Passing by ref passes a managed pointer, which occupies 8 bytes on a 64-bit architecture (or 4 bytes on a 32-bit architecture).

Consequently, passing small value types (like a 4-byte int) by ref consumes more stack space than passing by value and introduces pointer dereferencing overhead. The mechanical purpose of ref is to allow state mutation or to avoid the overhead of copying large structs, not to prevent garbage collection or heap allocation.

Extended ref Contexts

Modern C# expands the ref keyword beyond method parameters to support advanced memory safety and pointer manipulation:

ref Locals (C# 7.0) Declares a local variable that aliases another memory location.

int[] array = { 1, 2, 3 };
ref int alias = ref array[0];
alias = 42; // array[0] is now 42

ref Returns (C# 7.0) Allows a method to return a managed pointer to a memory location rather than a copied value. The returned reference must have a lifetime that exceeds the method’s execution (e.g., an array element or a ref parameter).

public ref int GetFirstElement(int[] array)
{
    return ref array[0];
}

ref struct (C# 7.2) A type declaration modifier that forces a struct to be allocated exclusively on the stack. A ref struct can never be boxed, assigned to a variable of type object, or captured in a closure. This is required for types that encapsulate managed pointers or stack-only memory, such as Span<T>.

public ref struct StackOnlyStruct
{
    public int Value;
}

ref Fields (C# 11) Allows a ref struct to declare fields that are managed pointers. This enables custom types to safely store references to other stack-allocated data or array elements.

public ref struct RefFieldStruct
{
    public ref int NumberRef;
}

Syntactic Restrictions

The compiler enforces strict limitations on managed pointers to ensure memory safety and prevent dangling references:

• Properties and Indexers: Cannot be passed as ref parameters. They are compiled as get/set method invocations and do not possess a single, addressable memory location.
• Async Methods: ref parameters, ref locals, and ref struct types are prohibited in async methods. The compiler-generated state machine cannot safely capture or preserve managed pointers across await boundaries, as the execution context may resume on a different thread with a different stack.
• Iterator Methods: ref parameters and ref struct types are prohibited in methods utilizing yield return or yield break due to similar state-machine lifting constraints.

Master C# with Deep Grasping Methodology!

Learn More