C# - Inheritance

Inheritance in C#

Inheritance is one of the core pillars of Object-Oriented Programming (OOP) in C#. It enables new classes to be based on existing classes, promoting code reuse, extensibility, and a clear hierarchical relationship between types. This detailed guide covers everything you need to know about inheritance in C#, from basic concepts to advanced usage, including examples and best practices.

1. Introduction to Inheritance

Inheritance allows a class (called the derived class or child class) to inherit members (fields, properties, methods, events) from another class (called the base class or parent class). This relationship models an "is-a" association — the derived class is a specialized version of the base class.

1.1 Why Use Inheritance?

• Code Reuse: Avoid rewriting common functionality by inheriting it from a base class.
• Extensibility: Extend or modify behavior without changing the original class.
• Polymorphism: Use a base class reference to refer to derived class objects for flexible code.
• Logical Hierarchies: Represent real-world relationships naturally.

1.2 Real-World Example

Consider a base class Animal and derived classes like Dog and Cat. Dogs and cats share common animal properties (like breathing and eating) but also have specialized behaviors.

2. Basic Syntax of Inheritance in C#

Inheritance is implemented using the colon (:) syntax after the derived class name.

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Barking...");
    }
}

In this example, Dog inherits Eat() method from Animal, and also has its own Bark() method.

2.1 Creating and Using Derived Class Objects

Dog myDog = new Dog();
myDog.Eat();  // Output: Eating...
myDog.Bark(); // Output: Barking...

3. Types of Inheritance in C#

C# supports several inheritance patterns:

3.1 Single Inheritance

One derived class inherits from one base class.

class Vehicle
{
    public void Start() => Console.WriteLine("Vehicle started.");
}

class Car : Vehicle
{
    public void Drive() => Console.WriteLine("Car is driving.");
}

3.2 Multilevel Inheritance

A class derives from a derived class.

class Animal
{
    public void Eat() => Console.WriteLine("Eating...");
}

class Mammal : Animal
{
    public void Walk() => Console.WriteLine("Walking...");
}

class Dog : Mammal
{
    public void Bark() => Console.WriteLine("Barking...");
}

3.3 Hierarchical Inheritance

Multiple classes inherit from a single base class.

class Animal
{
    public void Eat() => Console.WriteLine("Eating...");
}

class Dog : Animal
{
    public void Bark() => Console.WriteLine("Barking...");
}

class Cat : Animal
{
    public void Meow() => Console.WriteLine("Meowing...");
}

3.4 Multiple Inheritance (via Interfaces)

C# does not support multiple class inheritance but allows multiple interface inheritance.

interface IWalkable
{
    void Walk();
}

interface ISwimmable
{
    void Swim();
}

class Amphibian : IWalkable, ISwimmable
{
    public void Walk() => Console.WriteLine("Walking...");
    public void Swim() => Console.WriteLine("Swimming...");
}

4. Access Modifiers and Inheritance

Access modifiers control visibility of class members in inheritance scenarios.

4.1 Protected Members

protected members are accessible only within the class and its derived classes, which is key for inheritance encapsulation.

public class Animal
{
    protected string name;

    protected void SetName(string n)
    {
        name = n;
    }
}

public class Dog : Animal
{
    public void Initialize(string dogName)
    {
        SetName(dogName);
        Console.WriteLine($"Dog's name is {name}");
    }
}

5. Constructors and Inheritance

Derived classes do not inherit constructors but can call base class constructors explicitly using the base keyword.

5.1 Base Constructor Call

public class Person
{
    public string Name;

    public Person(string name)
    {
        Name = name;
    }
}

public class Employee : Person
{
    public int EmployeeId;

    public Employee(string name, int id) : base(name)
    {
        EmployeeId = id;
    }
}

5.2 Constructor Execution Order

When creating an object of a derived class:

• Base class constructor runs first.
• Then derived class constructor executes.

6. Method Overriding and Polymorphism

Inheritance allows derived classes to modify behavior of base class methods via overriding.

6.1 Virtual Methods

Base class methods declared with virtual can be overridden.

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog barks");
    }
}

6.2 Using Base Method in Override

You can call the base implementation from the override:

public override void Speak()
{
    base.Speak();
    Console.WriteLine("Dog barks");
}

6.3 Polymorphism and Late Binding

With polymorphism, base class references can point to derived objects:

Animal myAnimal = new Dog();
myAnimal.Speak(); // Output: Dog barks

This decision is made at runtime (late binding), enabling dynamic behavior.

6.4 Sealed Override

You can prevent further overriding using the sealed modifier:

public class Dog : Animal
{
    public sealed override void Speak()
    {
        Console.WriteLine("Dog barks");
    }
}

public class Puppy : Dog
{
    // Compile error if trying to override Speak()
}

7. New Keyword and Method Hiding

Derived classes can hide base class members using the new keyword instead of overriding.

public class BaseClass
{
    public void Show()
    {
        Console.WriteLine("Base Show");
    }
}

public class DerivedClass : BaseClass
{
    public new void Show()
    {
        Console.WriteLine("Derived Show");
    }
}

Unlike overriding, method hiding is resolved at compile time, based on reference type:

BaseClass obj1 = new DerivedClass();
obj1.Show();  // Output: Base Show

DerivedClass obj2 = new DerivedClass();
obj2.Show();  // Output: Derived Show

8. Abstract Classes and Methods

Abstract classes provide a base class with incomplete implementation and must be inherited.

8.1 Declaring Abstract Classes

public abstract class Shape
{
    public abstract double GetArea(); // Abstract method without body
}

8.2 Implementing Abstract Methods

public class Circle : Shape
{
    public double Radius;

    public Circle(double radius)
    {
        Radius = radius;
    }

    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

8.3 Cannot Instantiate Abstract Classes

// Shape shape = new Shape(); // Compile error

9. Interfaces and Inheritance

While classes support single inheritance, C# allows a class to implement multiple interfaces, enabling a form of multiple inheritance.

public interface IPlayable
{
    void Play();
}

public interface IRecordable
{
    void Record();
}

public class MediaPlayer : IPlayable, IRecordable
{
    public void Play() { Console.WriteLine("Playing media"); }
    public void Record() { Console.WriteLine("Recording media"); }
}

10. Best Practices for Using Inheritance

• Favor Composition over Inheritance: Use inheritance only when there is a clear "is-a" relationship.
• Keep Inheritance Hierarchies Shallow: Deep hierarchies are harder to maintain.
• Use Virtual and Override Wisely: Avoid unnecessary virtual methods for better performance and maintainability.
• Be Careful with Method Hiding: It can introduce subtle bugs if misunderstood.
• Prefer Interfaces for Multiple Inheritance: Use interfaces when you need to implement multiple behaviors.

11. Practical Example: Inheritance in a Banking System

public class Account
{
    public string AccountNumber { get; set; }
    public decimal Balance { get; protected set; }

    public Account(string number, decimal initialBalance)
    {
        AccountNumber = number;
        Balance = initialBalance;
    }

    public virtual void Deposit(decimal amount)
    {
        Balance += amount;
        Console.WriteLine($"Deposited {amount}, new balance: {Balance}");
    }

    public virtual void Withdraw(decimal amount)
    {
        if (amount <= Balance)
        {
            Balance -= amount;
            Console.WriteLine($"Withdrew {amount}, new balance: {Balance}");
        }
        else
        {
            Console.WriteLine("Insufficient funds");
        }
    }
}

public class SavingsAccount : Account
{
    public double InterestRate { get; set; }

    public SavingsAccount(string number, decimal balance, double interestRate)
        : base(number, balance)
    {
        InterestRate = interestRate;
    }

    public void AddInterest()
    {
        decimal interest = Balance * (decimal)InterestRate / 100;
        Deposit(interest);
        Console.WriteLine($"Interest added: {interest}");
    }
}

public class CheckingAccount : Account
{
    public decimal OverdraftLimit { get; set; }

    public CheckingAccount(string number, decimal balance, decimal overdraft)
        : base(number, balance)
    {
        OverdraftLimit = overdraft;
    }

    public override void Withdraw(decimal amount)
    {
        if (amount <= Balance + OverdraftLimit)
        {
            Balance -= amount;
            Console.WriteLine($"Withdrew {amount}, new balance: {Balance}");
        }
        else
        {
            Console.WriteLine("Exceeded overdraft limit");
        }
    }
}

Inheritance is a foundational concept in C# and OOP that facilitates reuse, organization, and polymorphism. It enables a derived class to inherit and modify behavior of a base class, promoting extensible and maintainable code.

Key points:

• Use inheritance to express "is-a" relationships.
• Derived classes inherit fields, properties, and methods of base classes.
• Virtual and override enable polymorphic behavior.
• Use base keyword to access base class members.
• Abstract classes define incomplete bases, interfaces enable multiple inheritance.
• Beware of deep hierarchies and method hiding pitfalls.

Mastering inheritance unlocks powerful design patterns and clean, scalable software architecture in C#.