Inheritance in C#

What is Inheritance in C#?

Inheritance in C# is a fundamental object-oriented programming concept that enables a class (known as a derived or child class) to inherit fields, methods, properties, and other members from another class (known as a base or parent class). This allows code reusability, enhances maintainability, and supports hierarchical classification.

Why Use Inheritance in C#?

The concept of Inheritance in C# provides several advantages:

• Promotes code reuse
• Reduces redundancy
• Improves code organization
• Supports polymorphism and abstraction
• Enables hierarchical modeling of real-world entities

Types of Inheritance in C#

Inheritance in C# supports the following types:

• Single Inheritance – One child class inherits from one base class
• Multilevel Inheritance – A class is derived from another derived class
• Hierarchical Inheritance – Multiple classes inherit from a single base class
• Interface Inheritance – Achieved via interfaces (since multiple inheritance is not allowed directly with classes in C#)

Note:

C# does not support multiple class inheritance directly to avoid ambiguity issues, but similar functionality can be achieved using interfaces.

Syntax of Inheritance in C#

The syntax to declare inheritance is:

📄
class BaseClass
{
    public void DisplayMessage()
    {
        Console.WriteLine("This is the base class method.");
    }
}

class DerivedClass : BaseClass
{
    public void ShowDerived()
    {
        Console.WriteLine("This is the derived class method.");
    }
}

Explanation:

• BaseClass defines a method called DisplayMessage().
• DerivedClass inherits BaseClass and can use its methods directly.

Access Modifiers in Inheritance in C#

Access modifiers determine the accessibility of class members in inheritance.

How to Use Base Keyword in Inheritance in C#

The base keyword is used to:

• Access base class methods
• Call base class constructors

📄
class Parent
{
    public Parent()
    {
        Console.WriteLine("Parent constructor");
    }
}

class Child : Parent
{
    public Child() : base()
    {
        Console.WriteLine("Child constructor");
    }
}

Method Overriding in Inheritance in C#

Derived classes can override base class methods using the override keyword. The base method must be marked with virtual.

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

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

Real-world Example of Inheritance in C#

Consider a simple real-world scenario of Vehicle as a base class and Car and Bike as derived classes.

📄
class Vehicle
{
    public string Brand = "Generic Brand";

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

class Car : Vehicle
{
    public string Model = "Sedan";
}

class Bike : Vehicle
{
    public string Type = "Sport";
}

Here, Car and Bike classes can use methods and properties from the Vehicle class.

Constructor Behavior in Inheritance in C#

When a derived class object is created, the base class constructor is automatically called before the derived class constructor executes.

Sealed Classes and Methods in Inheritance in C#

Sealed prevents further inheritance or method overriding.

📄
sealed class FinalClass
{
    // Cannot be inherited
}

class Base
{
    public virtual void Show() {}
}

class Derived : Base
{
    public sealed override void Show()
    {
        // Cannot be overridden again
    }
}

Benefits of Using Inheritance in C#

• Reduces code duplication
• Improves scalability and maintainability
• Supports better design architecture
• Enables polymorphism

Drawbacks of Inheritance in C#

• Tight coupling between base and derived classes
• Can lead to fragile code if not designed carefully
• Deep inheritance trees are hard to maintain

Conclusion

Inheritance in C# is a key pillar of object-oriented programming that enhances reusability and maintainability by enabling one class to acquire the properties and behaviors of another. Understanding its principles, types, and real-world usage is essential for effective C# programming.