C# Inheritance

Understanding Inheritance in C#

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a new class (called a derived class or subclass) to inherit properties and methods from an existing class (called a base class or superclass). This promotes code reusability and establishes a relationship between classes that share common characteristics.

The 'is-a' Relationship

Inheritance models an 'is-a' relationship. For example, a Car is a Vehicle. A Dog is an Animal. This means that a derived class is a specialized version of its base class.

Syntax for Inheritance

In C#, you use a colon (:) followed by the base class name to indicate inheritance.

public class DerivedClass : BaseClass
{
    // Members of DerivedClass
}

Example: A Simple Inheritance Hierarchy

Let's consider a Vehicle base class and a Car derived class.

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

    public void StartEngine()
    {
        Console.WriteLine("Engine started.");
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Brand: {Brand}, Year: {Year}");
    }
}

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

    public void Drive()
    {
        Console.WriteLine("Car is driving.");
    }

    // Overriding a virtual method from the base class
    public override void DisplayInfo()
    {
        base.DisplayInfo(); // Calls the base class's DisplayInfo
        Console.WriteLine($"Number of Doors: {NumberOfDoors}");
    }
}

Key Concepts in Inheritance

• Base Class (Superclass): The class from which properties and methods are inherited.
• Derived Class (Subclass): The class that inherits from a base class.
• 'this' keyword: Refers to the current instance of the class.
• 'base' keyword: Used to access members of the base class. This is crucial for calling base class constructors and methods, especially when overriding.
• Virtual Methods: Methods declared with the virtual keyword in the base class can be overridden by derived classes.
• Abstract Classes and Methods: Classes and methods can be declared as abstract, meaning they cannot be instantiated directly and must be implemented by derived classes.
• Sealed Classes and Methods: The sealed keyword prevents a class from being inherited or a method from being overridden.

Constructor Chaining

When a derived class object is created, the base class constructor is called first. You can use the base() syntax in the derived class constructor to explicitly call a specific base class constructor.

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

    // Constructor for Car, calling the base constructor
    public Car(string brand, int year, int doors) : base(brand, year)
    {
        NumberOfDoors = doors;
    }

    // ... other members
}

// Assuming Vehicle has a constructor like this:
public class Vehicle
{
    public string Brand { get; set; }
    public int Year { get; set; }

    public Vehicle(string brand, int year)
    {
        Brand = brand;
        Year = year;
    }
    // ...
}

Access Modifiers and Inheritance

Access modifiers (public, private, protected, internal) play a role in what members can be accessed by derived classes:

• public members are accessible everywhere.
• protected members are accessible within the class itself and by derived classes.
• internal members are accessible within the same assembly.
• private members are only accessible within the defining class.

Single vs. Multiple Inheritance

C# supports single inheritance for classes, meaning a class can inherit from only one direct base class. However, C# supports multiple interface implementation, which allows a class to implement multiple interfaces. This design choice helps to avoid the complexity and potential issues associated with multiple inheritance of implementation.

Benefits of Inheritance

• Code Reusability: Avoids duplicating code by defining common functionality in a base class.
• Extensibility: Allows new classes to be created based on existing ones, adding new features without modifying the original code.
• Polymorphism: Enables treating objects of derived classes as objects of their base class, which is essential for many design patterns.

Inheritance is a powerful tool for building well-structured and maintainable object-oriented applications. Mastering its principles is crucial for effective C# development.