# Solving Multiple Inheritance

A C# class can have only one base class, which avoids the confusion of inheriting two versions of the same method. Instead, it can implement as many interfaces as it needs, since an interface brings a contract, not code.

Journeyman · C# · OOP · Updated November 3, 2026

## After this lesson you can

- Explain why a C# class has only one base class but can implement many interfaces

## Key takeaways

- A C# class can have only one base class, so there's never a question of which parent's `TurnOn()` runs.
- A class can implement as many interfaces as it needs, because an interface brings a contract, not code.
- If two interfaces both list `TurnOn()`, the class writes one `TurnOn()` and keeps both contracts.
- A base class is an "is a" relationship; an interface is a "can do" one.

A riding mower is a vehicle: you sit on it, turn it on and drive it. It's also a lawn mower: you turn it on and it spins its blade. So shouldn't `RidingMower` inherit from both `Vehicle` and `LawnMower`?

## Two parents, one problem

Some languages allow that, and call it **multiple inheritance**. But look at what it would mean:

```csharp
public class Vehicle
{
    public void TurnOn()
    {
        Console.WriteLine("Engine started");
    }
}

public class LawnMower
{
    public void TurnOn()
    {
        Console.WriteLine("Blade spinning");
    }
}
```

Both classes have a finished `TurnOn()` method. If a riding mower inherited both, which one should `mower.TurnOn()` run? The engine's? The blade's? Both, and in which order? Every answer surprises someone, and in languages that allow it, this kind of question has caused many hard-to-find bugs.

C# avoids the question completely: **a class can have only one base class.**

```csharp
RidingMower mower = new RidingMower();

public class Vehicle
{
    public void TurnOn()
    {
        Console.WriteLine("Engine started");
    }
}

public class LawnMower
{
    public void TurnOn()
    {
        Console.WriteLine("Blade spinning");
    }
}

public class RidingMower : Vehicle, LawnMower
{
}
```

```text
error CS1721: Class 'RidingMower' cannot have multiple base classes: 'Vehicle' and 'LawnMower'
```

## Interfaces: many contracts, one class

A riding mower still needs to be usable as something you drive **and** as something that cuts grass. That's what interfaces are for. A class has one base class, but it can **implement** as many interfaces as it needs.

That's safe because an interface brings **no code**, only a contract. If two interfaces both list `TurnOn()`, there's nothing to choose between: the class writes **one** `TurnOn()`, and it keeps both contracts at once.

| | Base class | Interface |
|---|---|---|
| How many a class can have | One | As many as it needs |
| What it gives the class | Real code: properties, constructors, finished methods | A contract: what the class must be able to do |
| The relationship | *is a*: an archer **is a** character | *can do*: a riding mower **can be driven** and **can cut** |

So `RidingMower` might inherit from a `Machine` base class for what all machines share, such as a make and a model, and also implement an interface for driving and another for cutting. The next lesson writes exactly that.

## Check yourself

1 question to try on the lesson page.

## So what

One base class keeps inheritance simple: there's never a question of which parent's code runs. Interfaces add everything else a class can do, as contracts that can't clash.

## Key terms

- [Multiple Inheritance](https://www.ask-codey.com/glossary/multiple-inheritance-c-sharp)

## Cheat sheets

- [Solving Multiple Inheritance](https://www.ask-codey.com/cheat-sheets/interfaces-in-csharp-solving-multiple-inheritance-cheat-sheet)

Source: https://www.ask-codey.com/lessons/interfaces-in-csharp-solving-multiple-inheritance