How do interfaces work in modern C#? Explain what an interface can contain today (default interface methods, static abstract members), explicit implementation, how interface calls are dispatched, and the boxing trap with structs.

1. Interface maps in the runtime

Each class's MethodTable has an interface map listing implemented interfaces. For each interface, the runtime knows which class method implements each interface method (by name and signature, or explicit .override in IL for explicit implementations). Casting to an interface (is IFoo) checks the map (with caching).

2. Virtual stub dispatch (VSD)

call site --> indirection cell --> [lookup stub]   first call: resolve & patch
                                 --> [dispatch stub] monomorphic: cmp MT, jmp target
                                 --> [resolve stub]  polymorphic: hash table lookup

• Monomorphic sites are nearly as fast as virtual calls.
• Megamorphic sites (many types) pay a hash lookup per call.
• The stubs are shared per interface method slot and patched as behaviour changes.

Recent .NET versions have worked on alternatives (e.g. cached interface dispatch as used in NativeAOT), but the principle — per-call-site caching — is the same.

3. Default interface methods: resolution rules

• If the class (or a base class) implements the member, that wins.
• Otherwise the most specific default implementation in the interface hierarchy is used.
• If two interfaces provide conflicting defaults (diamond), the class must implement the member explicitly or the compiler/runtime reports an ambiguity (AmbiguousImplementationException at run time for binary changes).
• DIMs require runtime support (.NET Core 3.0+), so libraries targeting .NET Framework/netstandard2.0 can't use them.
• Calling a DIM on a struct via the interface boxes the struct; calling it via a constrained generic also boxes in some cases because the default implementation operates on this as the interface type.

4. Static abstract members under the hood

In IL, static abstract members are declared on the interface, and implementing types provide them. In generic code, calls use the constrained. prefix with a call to the static member, resolved per instantiation. For value types (the common case for generic math), the JIT generates specialised code and inlines operators — Sum<int> compiles to the same loop as a hand-written int sum (and may be vectorised).

The curiously recurring pattern where TSelf : IFoo<TSelf> lets interfaces refer to the implementing type for return types and operators.

5. Interfaces and versioning

• Adding a member without a default implementation to a public interface is a breaking change for all implementers.
• Options: default implementations, new derived interfaces (IFooV2 : IFoo), or capability interfaces checked at run time (if (stream is IAsyncDisposable ad)).
• Removing or changing members is always breaking.
• For application-internal interfaces, refactor freely.

6. Interfaces vs abstract classes (brief)

Interfaces: multiple inheritance of contracts, no state, work with structs, easy to mock. Abstract classes: shared state and constructors, protected members, template methods, single inheritance. Often both: an interface for the contract plus an optional abstract base class for convenience (e.g. IHostedService and BackgroundService).

Try it yourself

1. Add a default method to an interface and call it through the class and through the interface.
2. Implement INumber<T>-based Sum<T> and inspect the JIT disassembly for int.
3. Benchmark calling a struct's method via the interface vs via a constrained generic with [MemoryDiagnoser].
4. Create two interfaces with conflicting default methods and implement both.

public interface IPaymentGateway
{
    Task<ChargeResult> ChargeAsync(Money amount, CancellationToken ct);
    Task RefundAsync(string chargeId, CancellationToken ct);

    // Added in v2 without breaking existing implementers
    Task<PaymentStatus> GetStatusAsync(string chargeId, CancellationToken ct)
        => throw new NotSupportedException($"{GetType().Name} does not report status");
}

// Explicit implementation resolves a name clash
public interface IFileLog { void Write(string m); }
public interface IAudit   { void Write(string m); }
public sealed class AuditFileLog : IFileLog, IAudit
{
    void IFileLog.Write(string m) => File.AppendAllText("app.log", m);
    void IAudit.Write(string m)   => File.AppendAllText("audit.log", m);
}

// Static abstract members: one method for every numeric type
public static T Average<T>(ReadOnlySpan<T> values) where T : INumber<T>
{
    T sum = T.Zero;
    foreach (var v in values) sum += v;
    return sum / T.CreateChecked(values.Length);
}

// Constrained generic avoids boxing structs
public static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;