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.

// Positional syntax (generates a primary constructor and init-only properties)
public record Wrapper<T>(T Content, DateTime Timestamp);

// Nominal syntax (explicit property definition)
public record Container<T>
{
    public required T Item { get; init; }
}

// Generic record struct (value type semantics)
public readonly record struct Point<T>(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.

public record ConstrainedRecord<T>(T Value) where T : struct, IEquatable<T>;

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<TRecord>. For generic properties, it utilizes EqualityComparer<T>.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<T>.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.

var original = new Wrapper<int>(42, DateTime.UtcNow);

// The type of 'mutated' is strictly Wrapper<int>
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.

public record BaseRecord<T>(T Id);

// Inheriting and passing the type parameter
public record DerivedRecord<T, U>(T Id, U Payload) : BaseRecord<T>(Id);

// Inheriting and closing the generic type
public record ClosedDerivedRecord(string Id, int Count) : BaseRecord<string>(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<string> cannot be implicitly cast to a Wrapper<object>, even though string derives from object. Type parameters in generic records are strictly invariant.

Master C# with Deep Grasping Methodology!

Learn More