> ## 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# Sizeof The `sizeof` operator returns an `int` representing the unmanaged memory size, in bytes, of a specified type. This value includes any padding added by the compiler for memory alignment, but it does not reflect managed heap object overhead or stack alignment applied dynamically by the Common Language Runtime (CLR). ```csharp theme={"dark"} int size = sizeof(type); ``` ## Safe Context Evaluation Since C# 7.3, the `sizeof` operator can be used without an `unsafe` context for *any* unmanaged type. The evaluation behavior depends on the specific type: **Compile-Time Constants** For built-in simple types, the compiler replaces the `sizeof` expression with a constant integer value during compilation. This result can be assigned to a `const` variable. This applies to: * **Built-in Simple Types:** `sbyte` (1), `byte` (1), `short` (2), `ushort` (2), `int` (4), `uint` (4), `long` (8), `ulong` (8), `float` (4), `double` (8), `char` (2), `bool` (1), `decimal` (16). * **Enums:** Evaluates to the size of the enum's underlying type. ```csharp theme={"dark"} const int intSize = sizeof(int); // Evaluates to 4 at compile-time const int decimalSize = sizeof(decimal); // Evaluates to 16 at compile-time ``` **Runtime Evaluation** For custom unmanaged structs and unmanaged generic type parameters, the `sizeof` expression does **not** yield a compile-time constant. Instead, the C# compiler emits the `sizeof` IL instruction, which is evaluated by the JIT compiler at runtime (or during AOT compilation). Because it is not a constant expression, the result cannot be assigned to a `const` variable. The returned size accounts for field sizes plus any structural padding required for alignment. ```csharp theme={"dark"} public struct CustomPoint { public byte X; // 1 byte public int Y; // 4 bytes } // Valid in safe code, but NOT a compile-time constant. // Evaluates to 8 at runtime due to 3 bytes of padding added after 'X'. int structSize = sizeof(CustomPoint); int GetSize() where T : unmanaged { return sizeof(T); // Evaluated at runtime via IL instruction } ``` ## Unsafe Context Evaluation Evaluating the size of pointer types requires an `unsafe` context and requires compiling the project with the `AllowUnsafeBlocks` flag enabled. The size of a pointer depends on the architecture of the executing process. ```csharp theme={"dark"} unsafe { // Evaluates to 8 on a 64-bit architecture, 4 on a 32-bit architecture int pointerSize = sizeof(int*); } ``` ## Technical Constraints * **Reference Types:** `sizeof` cannot be applied to reference types (e.g., `class`, `string`, `object`, arrays). The CLR manages the memory layout of reference types dynamically, making their unmanaged size indeterminate. * **Managed Structs:** `sizeof` cannot be applied to structs that contain reference type fields, as they do not satisfy the `unmanaged` constraint. * **Unconstrained Generics:** `sizeof` cannot be applied to a generic type parameter unless the `unmanaged` constraint is explicitly applied.

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