Generic constraint for record types

[MinzigesTV]

Currently, C# does not provide a way to constrain a generic type parameter to only accept record types.

Problem

When writing generic code that operates on records, I often want to use the with { } expression to create a copy of the value. However, if my generic type parameter is constrained only by an interface, the compiler does not allow with { } because it cannot guarantee that the type is a record:

public interface IFilter { }

public record MyFilter(int Page, string Query) : IFilter;

public class Consumer<TFilter> where TFilter : IFilter
{
    public TFilter Clone(TFilter value)
    {
        // error: TFilter is not known to be a record type
        return value with { };
    }
}

This forces developers to introduce custom Clone() methods or additional interfaces, even though the compiler already knows that record types inherently support with.

Proposal

Introduce a new generic constraint that restricts a type parameter to record types, e.g.:

public class Consumer<TFilter> where TFilter : record, IFilter
{
    public TFilter Clone(TFilter value) => value with { };
}

Benefits

• Allows safe use of with { } on generic parameters.
• Removes the need for boilerplate Clone() implementations in every record.
• Symmetry with existing constraints (class, struct, unmanaged) and makes record-specific features usable in generic contexts.

Alternatives

• Require an explicit interface with a Clone() method → more boilerplate.
• Use ICloneable → not strongly typed, requires casting, and is generally discouraged.
• Reflection → inefficient and not type-safe.

Questions

• Should this cover both record class and record struct, or should they have separate constraints?
• Should it allow constraints like where T : record and where T : record struct?

[HaloFour]

See: #3859

[MinzigesTV]

Thank you, did not find that discussion.