> ## 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# Generic Struct A generic struct in C# is a user-defined value type that utilizes one or more type parameters to encapsulate data and behavior independently of specific underlying data types. As a value type, it is allocated on the stack or inline within containing types, and its generic nature ensures compile-time type safety while eliminating the performance overhead of boxing and unboxing operations when working with other value types. ## Syntax Declaration and Instantiation A generic struct is declared using angle brackets `` to define type parameters. ```csharp theme={"dark"} public struct Container { public T Item { get; } public Container(T item) { Item = item; } } // Instantiation Container intContainer = new Container(42); Container stringContainer = new Container("Data"); ``` ## Memory Layout and JIT Compilation The Common Language Runtime (CLR) handles generic structs differently depending on the type argument provided during instantiation: * **Value Type Arguments:** If `T` is a value type (e.g., `int`, `double`, or another `struct`), the Just-In-Time (JIT) compiler generates a distinct, specialized machine code implementation for that specific type. The memory footprint is calculated exactly based on the size of the inline value type. * **Reference Type Arguments:** If `T` is a reference type (e.g., `string`, `class`), the JIT compiler generates a single shared implementation for all reference types. The struct's memory footprint will contain a pointer (4 bytes on x86, 8 bytes on x64) to the heap-allocated object. ## Type Constraints Generic structs support type constraints using the `where` keyword to restrict the kinds of types that can be substituted for the type parameters. ```csharp theme={"dark"} public readonly struct DataProcessor where T : struct, IComparable { public T Data { get; } public DataProcessor(T data) { Data = data; } } ``` ## The `readonly` Modifier Because structs are copied by value, mutating them can lead to unexpected behavior (torn reads or modifying a copy instead of the original). It is a standard technical practice to mark generic structs as `readonly`. This forces all fields and properties to be immutable after initialization, allowing the compiler to optimize by passing the struct by `in` reference without creating defensive copies. ```csharp theme={"dark"} public readonly struct Point where T : unmanaged { public readonly T X; public readonly T Y; public Point(T x, T y) { X = x; Y = y; } } ``` ## Default Values and Initialization When a generic struct is initialized using the `default` keyword, the CLR zeroes out the memory space allocated for the struct. ```csharp theme={"dark"} // 'Item' will be 0 Container defaultInt = default; // 'Item' will be null Container defaultString = default; ``` *Note: As of C# 10, generic structs can declare explicit parameterless constructors. Prior to C# 10, parameterless constructors on structs were prohibited by the compiler.* ## Structural Limitations * **Inheritance:** Like all structs, generic structs implicitly inherit from `System.ValueType` (which inherits from `System.Object`). They cannot explicitly inherit from any class or struct, nor can they be inherited from. They are implicitly `sealed`. * **Interface Implementation:** Generic structs can implement interfaces. However, casting a generic struct to an interface type will cause a boxing operation, moving the value type to the heap. * **Self-Referencing:** A generic struct cannot contain a field of its own exact type, as the compiler must be able to compute the exact memory size of the struct at compile time. ```csharp theme={"dark"} public struct Node { public T Value; // CS0523: Struct member 'Node.Next' of type 'Node' causes a cycle in the struct layout public Node Next; } ```

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