> ## 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 Record A generic record in C# is a data-centric type that combines the value-based equality and non-destructive mutation semantics of records with the type safety of generics. It allows the definition of a record blueprint where one or more property types are deferred until instantiation via type parameters. ## Syntax and Declaration Generic records support both positional and nominal declaration styles. Type parameters are declared immediately following the record identifier. ```csharp theme={"dark"} // Positional syntax (generates a primary constructor and init-only properties) public record Wrapper(T Content, DateTime Timestamp); // Nominal syntax (explicit property definition) public record Container { public required T Item { get; init; } } // Generic record struct (value type semantics) public readonly record struct Point(T X, T Y); ``` ## Type Constraints Standard generic type constraints (`where` clauses) apply to generic records. In positional syntax, the constraint is placed after the primary constructor parameters. ```csharp theme={"dark"} public record ConstrainedRecord(T Value) where T : struct, IEquatable; ``` ## Compiler-Synthesized Members When the C# compiler generates a generic record, it synthesizes several members adapted to the type parameter `T`: 1. **Value Equality (`Equals` and `==`):** The compiler implements `IEquatable`. For generic properties, it utilizes `EqualityComparer.Default.Equals()` to ensure correct equality checks regardless of whether `T` resolves to a reference type or a value type. 2. **Hashing (`GetHashCode`):** The synthesized hash code incorporates the generic properties using `EqualityComparer.Default.GetHashCode()`. 3. **Deconstruction:** For positional generic records, the compiler generates a `Deconstruct` method matching the generic signature of the primary constructor. 4. **Formatting (`PrintMembers`):** The compiler generates a `PrintMembers` method that calls `ToString()` on the generic properties to support built-in record string formatting. ## Non-Destructive Mutation (`with` Expressions) Generic records fully support `with` expressions. The compiler synthesizes a hidden copy constructor that accepts an instance of the generic record. The resulting type of a `with` expression retains the exact constructed type of the original instance. ```csharp theme={"dark"} var original = new Wrapper(42, DateTime.UtcNow); // The type of 'mutated' is strictly Wrapper var mutated = original with { Content = 100 }; ``` ## Inheritance Rules Generic records follow strict inheritance rules specific to the record type system: * A `record class` can only inherit from another `record class` (or `object`). * A generic record can inherit from a non-generic record, provided it supplies the required base constructor arguments. * A generic record can inherit from another generic record, passing its type parameters up the inheritance chain. ```csharp theme={"dark"} public record BaseRecord(T Id); // Inheriting and passing the type parameter public record DerivedRecord(T Id, U Payload) : BaseRecord(Id); // Inheriting and closing the generic type public record ClosedDerivedRecord(string Id, int Count) : BaseRecord(Id); ``` ## Covariance and Contravariance Because generic records are classes or structs (not interfaces or delegates), their type parameters cannot be declared as covariant (`out`) or contravariant (`in`). A `Wrapper` cannot be implicitly cast to a `Wrapper