What are generic classes in C#? Why do generics exist, how do you declare and close a generic type, and how do static fields behave for each constructed type such as Cache<int> and Cache<string>?

1. Representation in metadata and runtime

• The compiler emits the generic type definition once, with type parameters in metadata (Cache`2 — the backtick and arity in the CLR name).
• At run time, each constructed type gets its own MethodTable (Cache<string, Product> and Cache<int, Product> are distinct types with distinct statics and type identity).
• typeof(Cache<,>) is the open definition; IsGenericTypeDefinition is true. GetGenericArguments() returns the type arguments of a closed type.

2. Code sharing vs specialisation

• For reference-type arguments, the JIT compiles the methods once using a canonical placeholder (__Canon) and shares that code across Cache<string,...>, Cache<Customer,...> etc. Type-specific information (for casts, typeof(T), statics) comes from a runtime dictionary passed implicitly.
• For value-type arguments, the JIT compiles separate specialised code per type (Cache<int,...>, Cache<Guid,...>), with T known exactly — enabling inlining and no boxing.

This is why generic collections of value types are fast, and why many value-type instantiations increase code size (relevant to NativeAOT).

3. Static fields and static constructors

Statics live in per-closed-type storage. The static constructor runs once per closed type, on first use. With shared code for reference types, accessing a static requires looking up the closed type's static base via the generic dictionary — slightly slower than non-generic statics, though the JIT optimises common cases.

Generic static caches are a well-known performance trick in the BCL:

EqualityComparer<T>.Default    // cached per T, with special handling for IEquatable<T>, enums, nullable
Array.Empty<T>()              // one empty array per T

4. Generic type identity and reflection

typeof(List<int>) == typeof(List<int>) is true (same constructed type). List<int> and List<long> are unrelated types — no conversion between them (see variance/invariance). Type.MakeGenericType closes types at run time; under NativeAOT that requires the instantiation to be known at compile time (or annotated), otherwise it fails.

5. When to make a class generic

Make a class generic when the type parameter is used across multiple members and state (containers, caches, result types Result<T>, repositories over entities). If only one method needs flexibility, make just the method generic. Avoid generics that add parameters without real type-safety benefit (e.g. Service<T> where T is never used meaningfully).

Try it yourself

1. Create Counter<T> and increment for several type arguments; print each count.
2. Print typeof(Cache<,>), typeof(Cache<string,int>) and their IsGenericTypeDefinition.
3. Benchmark List<int> vs ArrayList adding and summing 1 million ints with [MemoryDiagnoser].
4. Close a generic type with MakeGenericType and create an instance with Activator.CreateInstance.

namespace Generics.Demo;

public sealed record PagedResult<T>(IReadOnlyList<T> Items, int Page, int PageSize, int TotalCount)
{
    public int TotalPages => (int)Math.Ceiling(TotalCount / (double)PageSize);
    public bool HasNext => Page < TotalPages;
}

public static class Counter<T>
{
    public static int Value { get; private set; }

    static Counter() => Console.WriteLine($"Static ctor for {typeof(T).Name}");

    public static void Increment() => Value++;
}

public static class Program
{
    public static void Main()
    {
        var page = new PagedResult<string>(["a", "b"], Page: 1, PageSize: 2, TotalCount: 5);
        Console.WriteLine($"{page.TotalPages} pages, has next: {page.HasNext}");

        Counter<int>.Increment();
        Counter<int>.Increment();
        Counter<string>.Increment();
        Console.WriteLine($"int: {Counter<int>.Value}, string: {Counter<string>.Value}"); // 2, 1

        Console.WriteLine(typeof(Counter<>).IsGenericTypeDefinition);                     // True
        Console.WriteLine(typeof(Counter<int>).GetGenericTypeDefinition() == typeof(Counter<>)); // True
    }
}