How does inheritance work in C#? Explain single inheritance of classes, what a derived class inherits, base calls, member hiding with new versus overriding, protected members, and the problems that deep or misused inheritance causes.

1. How inheritance is represented at run time

Each class's MethodTable contains:

• a pointer to the parent MethodTable (used for casting: is/as walk this chain or use cached checks);
• a vtable whose first slots are inherited from the parent (in the same order), followed by new virtual methods.

When a derived class overrides a method, the derived vtable's slot for that method points to the derived implementation. A virtual call loads the object's MethodTable, indexes the slot, and calls it — so Base b = new Derived(); b.M() reaches Derived.M. A new (hiding) method gets a new slot (newslot in IL), so calls through the base reference still use the base slot.

Instance fields from the base are laid out first in the object, followed by derived fields, so a reference to a derived object is also a valid base reference.

2. Constructors and inheritance order

For new SmsNotification(...): derived field initialisers → base field initialisers → base constructor body → derived constructor body. Calling virtual methods from the base constructor runs derived code before the derived constructor has initialised its fields — avoid it.

3. Liskov Substitution Principle (LSP)

Barbara Liskov's rule: objects of a subtype must be usable wherever the base type is expected without altering correctness. Concretely, a subclass must not:

• strengthen preconditions (accept fewer inputs),
• weaken postconditions (guarantee less),
• break invariants of the base,
• throw new kinds of exceptions callers aren't prepared for (NotSupportedException on Add),
• change side-effect expectations.

BCL examples of tension: Stream has CanSeek/CanWrite flags because not every stream supports everything — the contract includes the flags, which keeps it honest. ReadOnlyCollection<T> implements IList<T> and throws on Add; IList<T>.IsReadOnly exists to signal that.

4. The fragile base class problem

public class CountingSet<T> : HashSet<T>
{
    public int Added { get; private set; }
    public new bool Add(T item) { Added++; return base.Add(item); }
}

Or the classic Java example: overriding both add and addAll when addAll internally calls add double-counts — depending on base implementation details you can't see. Inheritance couples you to the implementation of the base, not just its contract. Composition (wrap a set, delegate) couples only to the public interface.

5. Designing for inheritance

If a class is meant to be inherited:

• Document which methods are called by which ("self-use") and what overrides must do.
• Keep the number of virtual/protected members small; prefer template methods with protected abstract hooks.
• Don't call overridable methods from constructors.
• Test the extension points with real subclasses.
• Otherwise, seal the class (CA1852 suggests sealing internal types with no subclasses; sealed classes also enable devirtualisation).

6. Inheritance with EF Core

EF Core maps hierarchies with TPH (one table, discriminator column — default, fastest), TPT (table per type, joins — slower), or TPC (table per concrete type, EF Core 7+). Deep hierarchies in the domain model create complex mappings, wide sparse TPH tables or expensive TPT joins — another practical cost of inheritance.

Try it yourself

1. Implement a method with override and with new, call both through base and derived references, and explain the output.
2. Decompile and look for newslot in the IL for the new version.
3. Write a subclass that forgets base.Validate() and add a test that catches it.
4. Refactor a two-dimensional inheritance hierarchy (format × delivery) into composition.

public abstract class Account(string owner)
{
    public string Owner { get; } = owner;
    public decimal Balance { get; protected set; }

    public void Withdraw(decimal amount)
    {
        decimal total = amount + Fee(amount);       // template step: fee varies by type
        if (total > Balance) throw new InvalidOperationException("Insufficient funds");
        Balance -= total;
    }

    protected virtual decimal Fee(decimal amount) => 2.50m;
}

public sealed class SavingsAccount(string owner) : Account(owner)
{
    protected override decimal Fee(decimal amount) => 0m;     // specialise
}

public sealed class BusinessAccount(string owner) : Account(owner)
{
    protected override decimal Fee(decimal amount) =>
        base.Fee(amount) + amount * 0.001m;                    // extend base behaviour
}

// Hiding: compiles with warning CS0108 unless 'new' is written, and is not polymorphic
public class Animal { public string Sound() => "..."; }
public class Dog : Animal { public new string Sound() => "Woof"; }

Animal pet = new Dog();
Console.WriteLine(pet.Sound());          // "..." (static type Animal decides)
Console.WriteLine(((Dog)pet).Sound());   // "Woof"