Interface or abstract class: how do you choose in modern C#, now that interfaces can have default implementations and static abstract members? Give the criteria, real BCL examples of each, and when you would use both together.

1. Technical differences

2. Versioning in practice

The .NET team's historical guidance (Framework Design Guidelines, 2nd/3rd ed.) favoured abstract classes for evolvable public APIs because interfaces couldn't change. DIMs changed that partly, but:

• DIMs can't add state, so new features needing storage can't be added to an interface.
• DIMs need runtime support (.NET Core 3.0+); libraries targeting netstandard2.0 can't use them.
• Diamond conflicts across interfaces with defaults can cause AmbiguousImplementationException when assemblies are updated independently.

That's why newer BCL types like TimeProvider are abstract classes — the team expected to add virtual members later.

3. Mocking and testing

• Interfaces are trivially mockable (all members abstract or with defaults).
• Abstract classes: only abstract/virtual members can be overridden by mocks; non-virtual template methods run real code. That can be good (testing the template) or awkward (unexpected dependencies in the base constructor).
• Providing both lets consumers mock the interface while implementers test against the base with small subclasses.

4. Performance considerations

• Calls through an interface use virtual stub dispatch (fast when monomorphic); calls through an abstract class use vtables. Both can be devirtualised when the type is known.
• For structs, interfaces in generic constraints give zero-cost abstraction (specialised code, no boxing) — something abstract classes can't offer at all.
• Static abstract members enable generic algorithms over numeric types with no runtime dispatch.

5. Interface segregation and role interfaces

Prefer several small interfaces (IReadRepository<T>, IWriteRepository<T>) over one large one; a class can implement several. Abstract classes can't be combined that way, which is another reason interfaces are the default for contracts.

6. Decision summary

• Contract for consumers / DI / capabilities / structs / generic math → interface.
• Shared state, constructor validation, fixed algorithm with hooks → abstract class.
• Public library where both matter → interface + abstract base class.
• Evolving a widely implemented public contract with state needs → abstract class.

Try it yourself

1. Implement an interface + abstract base pair and write tests mocking the interface and subclassing the base.
2. Add a default interface method and a virtual method to an abstract class in a library; recompile a consumer and compare.
3. Implement IParsable<T> on a value object and write a generic ParseAll<T>.
4. Create a diamond with two interfaces providing conflicting defaults.

// Contract for the host: small and easy to fake
public interface IImporter
{
    string Format { get; }
    Task<ImportResult> ImportAsync(Stream input, IProgress<int> progress, CancellationToken ct);
}

// Base for implementers: shared state and a fixed algorithm
public abstract class ImporterBase : IImporter
{
    private readonly ILogger _logger;
    protected ImporterBase(ILogger logger) => _logger = logger;

    public abstract string Format { get; }

    public async Task<ImportResult> ImportAsync(Stream input, IProgress<int> progress, CancellationToken ct)
    {
        using var reader = new StreamReader(input);
        int rows = 0, failed = 0;
        while (await reader.ReadLineAsync(ct) is { } line)
        {
            try { await ParseRowAsync(line, ct); rows++; }
            catch (FormatException ex) { failed++; _logger.LogWarning(ex, "Bad row {Row}", rows + failed); }
            if ((rows + failed) % 1000 == 0) progress.Report(rows + failed);
        }
        return new ImportResult(rows, failed);
    }

    protected abstract ValueTask ParseRowAsync(string line, CancellationToken ct);
}

public sealed class CsvImporter(ILogger<CsvImporter> logger, IOrderSink sink) : ImporterBase(logger)
{
    public override string Format => "csv";
    protected override ValueTask ParseRowAsync(string line, CancellationToken ct) =>
        sink.AddAsync(OrderRow.ParseCsv(line), ct);
}

// Interface with static abstract members: something an abstract class cannot do
public interface IHasCode<TSelf> where TSelf : IHasCode<TSelf>
{
    static abstract TSelf FromCode(string code);
}