What is an abstract class in C#, and when would you use one? Explain abstract members, constructors and state in an abstract class, the template method pattern, and how abstract classes evolve compared with interfaces.

1. What abstract means to the compiler and runtime

• The C# compiler forbids new AbstractType() (CS0144). The type is marked abstract in metadata, and the runtime also refuses to instantiate it.
• Abstract methods are emitted as virtual abstract with no IL body; they get vtable slots that derived classes fill. A concrete class with an unfilled slot can't load (TypeLoadException), which the compiler prevents.
• Abstract properties are abstract getter/setter methods.
• A derived class can be abstract itself and leave members abstract for its subclasses, or re-abstract a virtual member (public abstract override string ToString();) to force further subclasses to implement it.

2. Protected constructors

A public constructor on an abstract class is pointless (nobody can call it directly) and analysers (CA1012) suggest protected. The constructor runs as part of the derived constructor chain, so it can validate shared parameters and establish invariants for every subclass.

Avoid calling abstract/virtual members from the base constructor (CA2214): the derived constructor body hasn't run yet.

3. Sealing the template

To stop subclasses overriding the algorithm:

• Make the template method non-virtual (the default in C#), or
• If it overrides an inherited virtual method, mark it sealed override.

Keep hooks protected (not public) so callers use the template, not the steps. Name hooks clearly (OnChargedAsync, ChargeCoreAsync) — the BCL uses the ...Core suffix convention (DisposeAsyncCore, ReadCore).

4. Abstract classes and testing

• You can't mock an abstract class's non-virtual members with most mocking libraries (Moq and NSubstitute mock virtual/abstract members only).
• To test the template logic, create a small test subclass in the test project with predictable step implementations.
• To test a concrete subclass, test it through the public template method.
• Keeping an interface alongside the base class lets consumers mock the interface without caring about the base class.

5. Abstract classes vs composition for the same problem

The template method can often be replaced by composition: PaymentProcessor taking an IProviderClient strategy. Trade-offs:

For one stable axis of variation with lots of shared behaviour, the template method is simple and clear. For multiple or changing axes, compose.

6. Abstract classes in EF Core

Abstract entity base classes (e.g. AuditableEntity with CreatedAt, UpdatedBy) are common. If the base isn't mapped as an entity, EF Core just maps inherited properties into each derived table. If you map the hierarchy (TPH/TPT/TPC), the abstract base becomes part of the inheritance mapping — decide deliberately; shared audit columns usually don't need a mapped hierarchy.

Try it yourself

1. Implement a template method with abstract and virtual hooks and a test subclass that records the call order.
2. Re-abstract ToString() in a base class and see the compiler force subclasses to implement it.
3. Refactor the same logic into a strategy-based design and compare readability and tests.
4. Enable CA1012 and CA2214 and check your abstract classes.

public abstract class Exporter
{
    private readonly IAuditLog _audit;

    protected Exporter(IAuditLog audit) =>
        _audit = audit ?? throw new ArgumentNullException(nameof(audit));

    // Template method: not virtual, so no subclass can skip a step
    public async Task<ExportFile> ExportAsync(User user, Query q, CancellationToken ct)
    {
        if (!user.CanExport) throw new UnauthorizedAccessException();
        var rows = await q.RunAsync(ct);
        var bytes = Render(rows);
        await _audit.RecordAsync(user.Id, GetType().Name, rows.Count, ct);
        return new ExportFile(FileName(q), ContentType, bytes);
    }

    protected abstract string ContentType { get; }
    protected abstract byte[] Render(IReadOnlyList<Row> rows);
    protected virtual string FileName(Query q) => $"{q.Name}-{DateTime.UtcNow:yyyyMMdd}";
}

public sealed class CsvExporter(IAuditLog audit) : Exporter(audit)
{
    protected override string ContentType => "text/csv";
    protected override byte[] Render(IReadOnlyList<Row> rows) =>
        Encoding.UTF8.GetBytes(string.Join('\n', rows.Select(r => r.ToCsv())));
}

// BCL example: BackgroundService is abstract
public sealed class OutboxWorker(IOutbox outbox) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
            await outbox.DispatchPendingAsync(stoppingToken);
    }
}