C# Inheritance for Beginners: Base and Derived Classes

Inheritance lets you build new classes on top of existing ones — reusing code, extending behavior, and modeling real‑world hierarchies.

Imagine you're building a system for a zoo. You have Animal — it has a name, age, and a method Eat(). Then you need Lion, Elephant, and Penguin. Each is an animal, but they have different behaviors: a lion Roar()s, an elephant Trumpet()s, a penguin Swim()s. You could copy‑paste the animal code into each class, but that's a maintenance nightmare. Instead, you use inheritance: you define a base Animal class, and then Lion, Elephant, and Penguin inherit from it. They automatically get all the animal's members and can add or override their own.

In this lesson, you'll learn what inheritance is, why it exists, how to use it correctly, and when to prefer composition over inheritance.

What Is It?

The Simple Explanation

Inheritance is a mechanism that allows you to define a new class (the derived or child class) based on an existing class (the base or parent class). The derived class automatically receives all the members (fields, methods, properties) of the base class and can add new members or override existing ones.

The Technical Definition

In C#, inheritance is a fundamental object‑oriented principle. A class can inherit from a single base class (single inheritance), but it can implement multiple interfaces. The derived class extends the base class and can:

• Inherit all non‑private members (fields, properties, methods, events, etc.)
• Override virtual and abstract members to provide specialized behavior
• Add new members that are not present in the base class
• Hide base class members using the new keyword (though this is rarely needed)

Inheritance establishes an "is‑a" relationship: a Lion is an Animal. This is also known as subtyping.

Why Does It Exist?

The Problem

Without inheritance, you'd have to duplicate common code across many classes. If you needed to add a new property or fix a bug, you'd have to change every class. This leads to code duplication, maintenance nightmares, and inconsistencies. Also, you'd lose the ability to treat different types uniformly (polymorphism).

The Solution

Inheritance solves these problems by:

• Code reuse — common logic lives in one place (the base class).
• Extensibility — you can add or override behavior in derived classes.
• Polymorphism — you can write code that works with the base class but actually uses derived class implementations at runtime.
• Modeling real‑world relationships — many domains have hierarchical classifications (e.g., Vehicle → Car → SportsCar).

Big Picture

Inheritance creates a hierarchy. Here's a typical inheritance chain in a .NET application:

How It Works

Step 1 — Define a base class

public class Animal
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Animal(string name) => Name = name;

    public virtual void Speak() => Console.WriteLine($"{Name} makes a sound.");
}

The virtual keyword allows derived classes to override the method.

Step 2 — Derive a class

public class Dog : Animal
{
    public Dog(string name) : base(name) { }

    public override void Speak() => Console.WriteLine($"{Name} barks!");
}

The : Animal syntax declares inheritance. The constructor calls the base constructor with base(name). override replaces the base method.

Step 3 — Polymorphic usage

Animal myAnimal = new Dog("Rex");
myAnimal.Speak(); // Output: "Rex barks!" (calls Dog's Speak)

The actual method called is determined at runtime based on the object's type, not the variable's type.

Step 4 — base keyword

public override void Speak()
{
    base.Speak(); // Call base implementation first
    Console.WriteLine("... and wags its tail!");
}

Use base to access base class members from the derived class.

Step 5 — Abstract classes and members

public abstract class Shape
{
    public abstract double GetArea(); // No implementation
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double GetArea() => Math.PI * Radius * Radius;
}

Abstract classes cannot be instantiated. They provide a template for derived classes.

Simple Example

public class Vehicle
{
    public string Brand { get; set; }
    public int Year { get; set; }

    public Vehicle(string brand, int year) => (Brand, Year) = (brand, year);

    public virtual void Start() => Console.WriteLine("Vehicle starting...");
}

public class Car : Vehicle
{
    public int NumberOfDoors { get; set; }

    public Car(string brand, int year, int doors) : base(brand, year)
    {
        NumberOfDoors = doors;
    }

    public override void Start()
    {
        base.Start();
        Console.WriteLine("Car engine roars to life!");
    }
}

// Usage
Car myCar = new Car("Tesla", 2023, 4);
myCar.Start();
// Output:
// Vehicle starting...
// Car engine roars to life!

Code → Meaning → Result

• Car inherits Brand and Year from Vehicle.
• It adds its own property NumberOfDoors.
• The constructor chains to the base constructor using base(brand, year).
• Start() overrides the base method, calling the base implementation and adding extra behavior.

Real-World Example

Consider an e‑commerce system that needs to handle different types of products. A base Product class provides common properties, and derived classes add specialized behavior.

public abstract class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }

    public virtual string GetDescription() => $"{Name} (${Price:F2})";

    public abstract decimal CalculateTax(); // Each product type has its own tax rule
}

public class ElectronicProduct : Product
{
    public int WarrantyMonths { get; set; }

    public override decimal CalculateTax() => Price * 0.20m; // 20% VAT

    public override string GetDescription() =>
        base.GetDescription() + $", Warranty: {WarrantyMonths} months";
}

public class BookProduct : Product
{
    public string Author { get; set; } = "";

    public override decimal CalculateTax() => Price * 0.05m; // 5% tax on books

    public override string GetDescription() =>
        base.GetDescription() + $", Author: {Author}";
}

// Usage in a service
public class CartService
{
    public decimal CalculateTotalTax(IEnumerable products)
    {
        decimal total = 0;
        foreach (var p in products)
            total += p.CalculateTax(); // Polymorphic call
        return total;
    }
}

// Example
var products = new List
{
    new ElectronicProduct { Id = 1, Name = "Laptop", Price = 1000, WarrantyMonths = 24 },
    new BookProduct { Id = 2, Name = "C# Basics", Price = 50, Author = "John Doe" }
};

var service = new CartService();
Console.WriteLine($"Total tax: {service.CalculateTotalTax(products):C}");
// Output: Total tax: $202.50 (200 + 2.5)

Why this is realistic:

• The Product abstract class defines a contract with an abstract method CalculateTax().
• Each derived class provides its own tax calculation.
• The CartService works with Product references and relies on polymorphism — it doesn't need to know the concrete type.

Analogy

Under the Hood

What happens inside the .NET runtime when you use inheritance and polymorphism?

Animal vtable: Speak → Animal.Speak()
Dog vtable:    Speak → Dog.Speak()   (overrides the entry)

Common Confusion

1. Inheritance vs Composition

Inheritance represents an "is‑a" relationship (a Dog is an Animal). Composition represents a "has‑a" relationship (a Car has an Engine). Favor composition over inheritance because it's more flexible and less fragile. Inheritance can lead to deep, brittle hierarchies.

2. Virtual vs Abstract vs Override

• virtual — a member that can be overridden but has a default implementation.
• abstract — a member with no implementation; must be overridden in a derived class. Can only exist in abstract classes.
• override — provides a new implementation for a virtual/abstract member from the base class.

3. Base class constructor vs derived constructor

The derived constructor must call the base constructor (implicitly if the base has a parameterless constructor, or explicitly with base(...)). If the base constructor is not called, the base class may not be properly initialized.

Common Mistakes

Mistake 1 — Forgetting to call the base constructor

public class Animal
{
    public Animal(string name) => Name = name;
}
public class Dog : Animal
{
    public Dog(string name) { } //  Compiler error: base constructor not called
}

Correct: public Dog(string name) : base(name) { }

Mistake 2 — Overriding a method without override or new

If you define a method with the same name as a base class method but without override, the compiler warns you that you are hiding the base member. This is usually unintended.

Use override to replace the base method, or new if you intentionally want to hide it (rare).

Mistake 3 — Deep inheritance hierarchies

Too many levels of inheritance make the code hard to understand and maintain. A good rule of thumb is to keep hierarchies shallow (max 3–4 levels). Prefer composition or interfaces to avoid deep chains.

Mistake 4 — Using inheritance for code reuse only

If you are inheriting just to reuse a few methods, and there is no "is‑a" relationship, you should favor composition (e.g., dependency injection, helper classes). Inheritance creates a tight coupling between classes.

When Should I Use It?

Use inheritance when:

• There is a clear "is‑a" relationship (e.g., Car is a Vehicle).
• You need to share common code across multiple classes.
• You want to enable polymorphism — treat derived objects as base objects.
• You are designing a framework or library where base classes provide a template for extensibility.

Avoid inheritance when:

• The relationship is "has‑a" (composition is more appropriate).
• You only need to reuse a few methods — consider composition or extension methods.
• You expect the hierarchy to change frequently — inheritance makes changes ripple through the hierarchy.
• You are working with value types (structs) — they cannot inherit.

Mental Model

Key Takeaway

Check Your Understanding

You've learned the ins and outs of inheritance. Let's see if you can apply these concepts in practice.

class Base { public virtual void M() => Console.Write("Base"); }
class Derived : Base { public override void M() => Console.Write("Derived"); }

Base obj = new Derived();
obj.M();

You now have a solid understanding of inheritance — from basic syntax to design principles!