What generic constraints does C# support? Explain class, class?, struct, unmanaged, notnull, new(), base-class, interface, naked type, Enum and Delegate constraints, and the C# 13 allows ref struct anti-constraint, with an example of when you need each.

1. How constraints are represented

Constraints are stored in metadata on generic parameters (GenericParamConstraint table plus flags like ReferenceTypeConstraint, NotNullableValueTypeConstraint, DefaultConstructorConstraint). unmanaged is emitted as struct + modreq(UnmanagedType) + an attribute so older compilers can't misuse it. notnull and class? are compiler-level nullable annotations. allows ref struct sets a new flag the runtime (.NET 9+) understands.

2. new() and performance

new T() in generic code historically compiled to Activator.CreateInstance<T>() — reflection-based and slow. Modern runtimes optimise it significantly (and for value types it's just default), but for hot paths a factory delegate (Func<T>) or static abstract static T Create() member is faster and more flexible (supports constructor parameters).

3. Constraints and overload resolution

Constraints aren't part of the method signature, so you can't overload by constraint. C# 7.3 improved resolution: candidates whose constraints aren't satisfied are discarded early in more cases, reducing confusing errors. Still, design APIs with different names rather than relying on constraint-based selection.

4. unmanaged in detail

A type is unmanaged if it's a primitive numeric type, char, bool, an enum, a pointer, or a struct whose fields are all unmanaged (recursively, including generic structs since C# 8). This guarantees no GC references, so the memory can be copied as raw bytes, stack-allocated, pinned trivially, and passed to native code. Generic math types like int, double, Half and Int128 are unmanaged.

5. allows ref struct and what it unlocks

Ref structs couldn't be type arguments because generic code might box them, store them in fields, or capture them. The anti-constraint promises the generic code won't do those things (the compiler enforces ref-safety rules for T inside). .NET 9 annotated many BCL types (Func<>, Action<>, IEnumerable<T>-like interfaces in some cases, SearchValues, comparers) so spans can flow through generic APIs, enabling more zero-allocation code.

6. Nullable interplay

• Unconstrained T? means "default of T" (nullable for references, unchanged for values).
• where T : struct makes T? Nullable<T>.
• where T : class makes T? a nullable reference.
• where T : notnull warns when nullable types are used as arguments.

Try it yourself

1. Write Max<T> with and without IComparable<T> constraint (using Comparer<T>.Default) and benchmark with int.
2. Use where T : unmanaged with stackalloc T[16] and sizeof(T).
3. Write an enum helper with where T : struct, Enum and a static generic cache.
4. Write a generic method with allows ref struct and call it with ReadOnlySpan<char>.

using System.Numerics;
using System.Runtime.InteropServices;

namespace Generics.Constraints;

public abstract class EntityBase
{
    public Guid Id { get; init; } = Guid.NewGuid();
}

public sealed class Customer : EntityBase
{
    public string Name { get; set; } = "";
}

public readonly record struct Header(int MessageType, int Length);

public interface IHasLength
{
    int Length { get; }
}

public ref struct Utf8Token(ReadOnlySpan<byte> bytes) : IHasLength
{
    private readonly ReadOnlySpan<byte> _bytes = bytes;
    public int Length => _bytes.Length;
}

public static class Constrained
{
    public static T Sum<T>(ReadOnlySpan<T> values) where T : INumber<T>
    {
        var total = T.Zero;
        foreach (var v in values) total += v;
        return total;
    }

    public static T ReadStruct<T>(ReadOnlySpan<byte> buffer) where T : unmanaged
        => MemoryMarshal.Read<T>(buffer);

    public static T CreateEntity<T>() where T : EntityBase, new() => new T();

    public static IReadOnlyList<string> EnumNames<T>() where T : struct, Enum
        => Enum.GetNames<T>();

    public static void AddAll<T, TDerived>(ICollection<T> target, IEnumerable<TDerived> items) where TDerived : T
    {
        foreach (var item in items) target.Add(item);
    }

    // allows ref struct must be the last item in the constraint clause (C# 13+)
    public static int Length<T>(T text) where T : IHasLength, allows ref struct
        => text.Length;
}

public static class Program
{
    public static void Main()
    {
        Console.WriteLine(Constrained.Sum<int>([1, 2, 3]));
        Console.WriteLine(Constrained.Sum<decimal>([1.5m, 2.25m]));

        Span<byte> bytes = stackalloc byte[8];
        BitConverter.TryWriteBytes(bytes, 7);
        BitConverter.TryWriteBytes(bytes[4..], 128);
        Console.WriteLine(Constrained.ReadStruct<Header>(bytes));

        Console.WriteLine(Constrained.CreateEntity<Customer>().Id);
        Console.WriteLine(string.Join(",", Constrained.EnumNames<DayOfWeek>()));
        Console.WriteLine(Constrained.Length(new Utf8Token("hello"u8)));
    }
}