What is polymorphism in C#? Explain compile-time (overloading, generics) and run-time (virtual dispatch, interfaces) polymorphism, how virtual dispatch works under the hood, and how pattern matching relates to it.

1. Vtable dispatch in detail

obj --> [header][MethodTable*][fields]
                   |
                   v
        MethodTable: [..., parent*, ..., vtable slot 0 (ToString), slot 1 (Equals), slot 2 (GetHashCode), slot 3 (Finalize), slot 4 (Area) ...]

A virtual call s.Area() compiles (x64, roughly) to:

mov rax, [rcx]          ; MethodTable
mov rax, [rax + 0x40]   ; vtable chunk
call [rax + 0x20]       ; slot for Area

The cost is small (a couple of dependent loads + indirect branch, usually well predicted). The bigger cost is lost inlining: an inlined Area might be folded into the loop and vectorised; a virtual one can't.

2. Virtual stub dispatch for interfaces

Interface slots differ per implementing type, so call sites use stubs:

1. Lookup stub: on first call, resolve the target via the type's interface map, then patch the call site.
2. Dispatch stub (monomorphic): compare the object's MethodTable with a cached one; on match jump directly.
3. Resolve stub (polymorphic): hash-table lookup when many types appear at the site.

So interface calls at monomorphic sites are about as fast as virtual calls; megamorphic sites are slower. (.NET has been moving some scenarios to "cached interface dispatch" similar to NativeAOT.)

3. Devirtualisation

This is why sealing classes (CA1852) and using generic constraints instead of interface parameters on hot paths have real performance benefits.

4. Ad-hoc, parametric and subtype polymorphism

In type theory:

• Ad-hoc: overloading and operator overloading — different implementations per type, chosen statically.
• Parametric: generics — one implementation for all types.
• Subtype: inheritance/interfaces — a value of a subtype used where the supertype is expected.
• C# 11's static abstract interface members add a form of type-class polymorphism (generic math): T.Zero, T.Parse, operators on T.

5. Double dispatch

Virtual calls dispatch on one object (the receiver). To dispatch on two runtime types (e.g. collision between Shape pairs), options are the visitor pattern (two virtual calls), a pattern-matching switch on a tuple (a, b) switch { (Circle, Rect) => ... }, or dynamic (slow, runtime-checked).

6. Pattern matching performance

The compiler turns type patterns into a sequence of isinst checks (or a decision DAG). For a handful of types it's comparable to virtual dispatch; for many types, ordering matters. Sealed records in a closed hierarchy make the switch both fast and exhaustive-looking (still requires _ until C# gets closed hierarchies / unions).

Try it yourself

1. Benchmark summing areas via virtual calls with a sealed vs non-sealed class, and with mixed types.
2. Use DOTNET_JitDisasm to see guarded devirtualisation with PGO enabled.
3. Implement the same feature with virtual methods and with a switch expression; add a new shape and a new operation to each and compare the edits.
4. Write a generic Sum<T> with INumber<T> and call it with int and decimal.

// Run-time polymorphism via an interface
public interface ICarrier
{
    string Code { get; }
    decimal Quote(Parcel parcel);
}

public sealed class AusPostCarrier : ICarrier
{
    public string Code => "AUSPOST";
    public decimal Quote(Parcel p) => 9.95m + p.WeightKg * 1.20m;
}

public sealed class CourierCarrier : ICarrier
{
    public string Code => "COURIER";
    public decimal Quote(Parcel p) => p.Express ? 25m : 15m;
}

public sealed record Parcel(decimal WeightKg, bool Express);

public sealed class QuoteService(IEnumerable<ICarrier> carriers)
{
    public IReadOnlyList<(string Carrier, decimal Price)> QuoteAll(Parcel parcel) =>
        carriers.Select(c => (c.Code, c.Quote(parcel))).OrderBy(q => q.Item2).ToList();
}

// Compile-time polymorphism: generics with static abstract members (generic maths)
static T Sum<T>(IEnumerable<T> values) where T : INumber<T>
{
    T total = T.Zero;
    foreach (var v in values) total += v;
    return total;
}

int a = Sum([1, 2, 3]);            // 6
decimal b = Sum([1.5m, 2.5m]);     // 4.0

// External polymorphism: closed hierarchy + pattern matching
public abstract record Shape;
public sealed record Circle(double R) : Shape;
public sealed record Rect(double W, double H) : Shape;

static double Area(Shape s) => s switch
{
    Circle c => Math.PI * c.R * c.R,
    Rect r   => r.W * r.H,
    _        => throw new ArgumentOutOfRangeException(nameof(s))
};