> ## 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# Stackalloc The `stackalloc` operator allocates a contiguous block of memory on the execution stack rather than the managed heap. Because the memory is allocated on the stack, it is not subject to garbage collection (GC) and is automatically reclaimed when the method in which it was allocated returns. ## Syntax and Return Types The operator can be assigned to two different types, which dictates whether the execution context must be marked as `unsafe`. **1. Safe Context (`Span` / `ReadOnlySpan`)** Introduced in C# 7.2, `stackalloc` can be assigned to a `Span` or `ReadOnlySpan` without requiring the `unsafe` keyword or compiler flag. This provides memory safety bounds checking. ```csharp theme={"dark"} Span safeBuffer = stackalloc int[10]; ReadOnlySpan safeReadOnlyBuffer = stackalloc byte[256]; ``` **2. Unsafe Context (Pointers)** Historically, `stackalloc` was strictly an unsafe operation that returned a pointer to the first element of the allocated block. This requires the `unsafe` context. ```csharp theme={"dark"} unsafe { int* unsafeBuffer = stackalloc int[10]; } ``` ## Initialization You can initialize the memory block at the time of allocation using collection initializer syntax. When an initializer is provided, the length can be inferred. ```csharp theme={"dark"} // Explicit length and type Span explicitInit = stackalloc int[3] { 10, 20, 30 }; // Inferred length Span inferredLength = stackalloc int[] { 10, 20, 30 }; // Inferred length and type Span fullyInferred = stackalloc[] { 10, 20, 30 }; ``` ## Technical Constraints and Rules * **Type Restrictions:** The type `T` in `stackalloc T[length]` must be an *unmanaged type*. This includes primitive types (like `int`, `float`, `byte`), `enum` types, pointers, or user-defined `struct` types that contain only unmanaged fields. You cannot use `stackalloc` with reference types or structs containing reference types. * **Memory Limits:** The execution stack has a fixed, limited size (typically 1 MB to 4 MB depending on the OS and environment). Allocating a block larger than the available stack space will result in a non-catchable `StackOverflowException`, terminating the process. * **Zero-Initialization:** By default, all memory allocated via `stackalloc` (whether assigned to a pointer or a `Span`) is zero-initialized. The C# compiler enforces this by emitting the `initlocals` flag on the method, which causes the `localloc` IL instruction to zero out the memory. However, if the `[System.Runtime.CompilerServices.SkipLocalsInit]` attribute is applied to the method or module, the compiler omits the `initlocals` flag. In this scenario, both pointer and `Span` allocations are left uninitialized and will contain garbage data. * **Contextual Restrictions:** * `stackalloc` cannot be used inside `catch` or `finally` blocks. * **Async and Iterator Methods:** Since C# 8.0, `stackalloc` is permitted in `async` methods and iterator methods (`yield`) provided the result is assigned to a `Span` or `ReadOnlySpan`. However, the resulting span cannot be used across `await` or `yield` boundaries, as the stack frame is suspended and the memory would become invalid. Assigning `stackalloc` to a pointer type remains strictly prohibited in `async` and iterator methods. * **Expression Usage:** When assigned to a `Span`, `stackalloc` is a valid expression and can be used inline within other operations, such as method arguments or conditional expressions. ```csharp theme={"dark"} // Inline expression usage void ProcessData(Span data) { /* ... */ } ProcessData(stackalloc byte[] { 0x01, 0x02, 0x03 }); // Conditional allocation int length = 5; Span buffer = length <= 128 ? stackalloc int[length] : new int[length]; ```

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