C# Inheritance

by

In C#, inheritance is a fundamental object-oriented programming concept that allows you to create new classes based on existing classes. It enables code reuse, promotes modularity, and supports the concept of a hierarchical class structure.

To define a class that inherits from another class, you use the colon (:) symbol followed by the name of the base class. The derived class, also known as the subclass or child class, inherits all the members (fields, properties, methods) from the base class, which is referred to as the superclass or parent class.

Here’s an example of a simple inheritance scenario in C#:

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

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

    public void Stop()
    {
        Console.WriteLine("Engine stopped.");
    }
}

// Derived class
class Car : Vehicle
{
    public void Accelerate()
    {
        Console.WriteLine("Car is accelerating.");
    }
}

In the example above, we have a Vehicle class as the base class, which defines common properties and methods for any type of vehicle. The Car class is derived from the Vehicle class using the : syntax.

The Car class inherits the Brand and Year properties from the Vehicle class, as well as the Start() and Stop() methods. Additionally, the Car class introduces its own method called Accelerate().

You can create instances of the derived class and access both the inherited members and the members specific to the derived class:

Car myCar = new Car();
myCar.Brand = "Ford";
myCar.Year = 2022;

myCar.Start();     // Inherited from the base class
myCar.Accelerate(); // Specific to the derived class
myCar.Stop();      // Inherited from the base class

In this example, you can see how we create an instance of the Car class, set its properties, and call methods inherited from the base class (Start() and Stop()), as well as the method specific to the derived class (Accelerate()).

Inheritance in C# supports single inheritance, which means a class can only inherit from a single base class. However, you can create a class hierarchy by defining multiple levels of inheritance, where each derived class can become a base class for another derived class.

Note that in C#, you can also use interfaces to achieve a form of multiple inheritance, where a class can implement multiple interfaces.

Advantage of C# Inheritance:

There are several advantages to using inheritance in C#:

  1. Code Reusability: Inheritance allows you to reuse code from existing classes. By deriving a new class from a base class, you inherit all the members of the base class without having to rewrite them. This promotes code reuse and saves development time.
  2. Modularity: Inheritance promotes modularity by organizing classes into a hierarchical structure. You can create a base class that defines common behaviors and properties, and then derive specialized classes from it. This makes the code more structured and easier to understand and maintain.
  3. Polymorphism: Inheritance enables polymorphism, which is a powerful object-oriented programming concept. Polymorphism allows you to treat objects of derived classes as objects of their base class. This means you can use a derived class object wherever the base class is expected, which leads to more flexible and extensible code.
  4. Method Overriding: In C#, derived classes can override methods inherited from the base class. This means you can provide a specialized implementation of a method in the derived class that overrides the behavior defined in the base class. Method overriding allows you to customize the behavior of objects based on their specific types.
  5. Code Extensibility: Inheritance provides a mechanism for extending the functionality of existing classes. You can create new derived classes that add new members or modify the behavior of the base class. This allows you to extend the capabilities of your code without modifying the existing code.
  6. Type Hierarchy: Inheritance establishes a type hierarchy, which helps in organizing and categorizing related classes. You can create a class hierarchy that reflects the relationships between different types of objects in your application domain. This helps in better understanding and managing the relationships between classes.

Overall, inheritance in C# provides a powerful and flexible mechanism for creating and organizing classes. It promotes code reuse, modularity, polymorphism, and extensibility, which are key principles of object-oriented programming.

C# Single Level Inheritance Example: Inheriting Fields

Certainly! Here’s an example of single level inheritance in C# where a derived class inherits fields from a base class:

class Animal
{
    protected string name;
    protected int age;

    public Animal(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {name}, Age: {age}");
    }
}

class Dog : Animal
{
    private string breed;

    public Dog(string name, int age, string breed) : base(name, age)
    {
        this.breed = breed;
    }

    public void Bark()
    {
        Console.WriteLine("Woof! Woof!");
    }

    public void DisplayBreed()
    {
        Console.WriteLine($"Breed: {breed}");
    }
}

In this example, we have a base class Animal that has two protected fields: name and age. The class also has a constructor to initialize these fields and a DisplayInfo() method to display the information.

The derived class Dog is inheriting from Animal using the : base(name, age) syntax in its constructor. It adds an additional private field breed. The Dog class has its own methods Bark() and DisplayBreed().

You can create an instance of the Dog class, set the values of inherited fields (name and age), and access the methods specific to the Dog class:

Dog myDog = new Dog("Max", 3, "Labrador Retriever");

myDog.DisplayInfo();    // Inherited from the base class
myDog.Bark();           // Specific to the derived class
myDog.DisplayBreed();   // Specific to the derived class

When you run this code, it will display the following output:

Name: Max, Age: 3
Woof! Woof!
Breed: Labrador Retriever

As you can see, the Dog class inherits the name and age fields from the Animal class. It can access and display the values of these fields using the DisplayInfo() method inherited from the base class. Additionally, the Dog class introduces its own methods Bark() and DisplayBreed().

C# Single Level Inheritance Example: Inheriting Methods

Certainly! Here’s an example of single level inheritance in C# where a derived class inherits methods from a base class:

class Shape
{
    public void DisplayShape()
    {
        Console.WriteLine("This is a shape.");
    }

    public virtual void CalculateArea()
    {
        Console.WriteLine("Calculating area of the shape...");
    }
}

class Circle : Shape
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public override void CalculateArea()
    {
        double area = Math.PI * radius * radius;
        Console.WriteLine($"Area of the circle: {area}");
    }
}

In this example, we have a base class Shape that has a method DisplayShape() and a virtual method CalculateArea(). The DisplayShape() method simply displays a message indicating that it’s a shape. The CalculateArea() method is marked as virtual, indicating that it can be overridden in the derived classes.

The derived class Circle inherits from Shape using the : Shape syntax. It adds an additional private field radius. The Circle class overrides the CalculateArea() method to calculate the area of a circle based on the provided radius.

You can create an instance of the Circle class, set the radius, and call the inherited and overridden methods:

Circle myCircle = new Circle(5.0);

myCircle.DisplayShape();    // Inherited from the base class
myCircle.CalculateArea();   // Overridden method specific to the derived class

When you run this code, it will display the following output:

This is a shape.
Area of the circle: 78.53981633974483

As you can see, the Circle class inherits the DisplayShape() method from the Shape class. It can call and display the message using this inherited method. The Circle class also overrides the CalculateArea() method to provide its own implementation specific to calculating the area of a circle.

Note that the virtual keyword is used in the base class’s CalculateArea() method, and the override keyword is used in the derived class’s CalculateArea() method to indicate that it overrides the base class’s implementation. This enables polymorphism, allowing the appropriate method to be called based on the actual type of the object.

C# Multi Level Inheritance Example:

Certainly! Here’s an example of multi-level inheritance in C# where a derived class inherits from another derived class:

class Animal
{
    protected string name;

    public Animal(string name)
    {
        this.name = name;
    }

    public void Eat()
    {
        Console.WriteLine($"{name} is eating.");
    }
}

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

    public void GiveBirth()
    {
        Console.WriteLine($"{name} is giving birth.");
    }
}

class Dolphin : Mammal
{
    public Dolphin(string name) : base(name)
    {
    }

    public void Swim()
    {
        Console.WriteLine($"{name} is swimming.");
    }
}

In this example, we have a base class Animal that has a protected field name and a method Eat(). The class represents generic animal behavior.

The derived class Mammal inherits from Animal and adds a method GiveBirth(). It represents mammalian behavior and adds the capability of giving birth.

The derived class Dolphin inherits from Mammal and adds a method Swim(). It represents specific behavior for dolphins and adds the capability of swimming.

You can create an instance of the Dolphin class and access the methods inherited from both the Animal and Mammal classes:

Dolphin dolphin = new Dolphin("Flipper");

dolphin.Eat();        // Inherited from Animal
dolphin.GiveBirth();  // Inherited from Mammal
dolphin.Swim();       // Specific to Dolphin

When you run this code, it will display the following output:

Flipper is eating.
Flipper is giving birth.
Flipper is swimming.

As you can see, the Dolphin class inherits the Eat() method from the Animal class through the intermediate Mammal class. It also inherits the GiveBirth() method from the Mammal class. Additionally, the Dolphin class introduces its own method Swim(), which is specific to dolphins.

This example demonstrates how multi-level inheritance allows you to build a hierarchy of classes with each derived class inheriting and extending the functionality of its parent classes.