> ## 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 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. ```csharp theme={"dark"} 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. ```csharp theme={"dark"} public void ReassignReference(ref List list) { // Reassigns the caller's reference to a new heap allocation list = new List(); } ``` ## 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. ```csharp theme={"dark"} 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). ```csharp theme={"dark"} 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`. ```csharp theme={"dark"} 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. ```csharp theme={"dark"} 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.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More