Inheritance is a fundamental concept of object-oriented programming that allows a class (called a derived class or child class) to inherit fields and methods from another class (called a base class or parent class). This promotes code reusability and establishes a relationship between classes.

There are several types of inheritance in C#:

1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multilevel Inheritance
5. Multiple Inheritance (not directly supported but can be achieved through interfaces)

1. Single Inheritance

In single inheritance, a derived class inherits from a single base class.

Example:

csharp
1class Animal // Base class
2{
3    public void Eat()
4    {
5        Console.WriteLine("Eating...");
6    }
7}
8
9class Dog : Animal // Derived class
10{
11    public void Bark()
12    {
13        Console.WriteLine("Barking...");
14    }
15}
16
17class Program
18{
19    static void Main(string[] args)
20    {
21        Dog dog = new Dog();
22        dog.Eat(); // Inherited method
23        dog.Bark(); // Dog's own method
24    }
25}

2. Multilevel Inheritance

In multilevel inheritance, a class is derived from another derived class.

Example:

csharp
1class Animal // Base class
2{
3    public void Eat()
4    {
5        Console.WriteLine("Eating...");
6    }
7}
8
9class Dog : Animal // Intermediate derived class
10{
11    public void Bark()
12    {
13        Console.WriteLine("Barking...");
14    }
15}
16
17class Puppy : Dog // Derived from Dog
18{
19    public void Weep()
20    {
21        Console.WriteLine("Weeping...");
22    }
23}
24
25class Program
26{
27    static void Main(string[] args)
28    {
29        Puppy puppy = new Puppy();
30        puppy.Eat(); // Inherited from Animal
31        puppy.Bark(); // Inherited from Dog
32        puppy.Weep(); // Puppy’s own method
33    }
34}

3. Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from a single base class.

Example:

csharp
1class Animal // Base class
2{
3    public void Eat()
4    {
5        Console.WriteLine("Eating...");
6    }
7}
8
9class Dog : Animal // Derived class 1
10{
11    public void Bark()
12    {
13        Console.WriteLine("Barking...");
14    }
15}
16
17class Cat : Animal // Derived class 2
18{
19    public void Meow()
20    {
21        Console.WriteLine("Meowing...");
22    }
23}
24
25class Program
26{
27    static void Main(string[] args)
28    {
29        Dog dog = new Dog();
30        dog.Eat(); // Inherited from Animal
31        dog.Bark(); // Dog's own method
32
33        Cat cat = new Cat();
34        cat.Eat(); // Inherited from Animal
35        cat.Meow(); // Cat's own method
36    }
37}

4. Multiple Inheritance (via Interfaces)

C# does not support multiple inheritance directly (i.e., a class cannot inherit from more than one class). However, a class can implement multiple interfaces.

Example:

csharp
1interface IAnimal // Interface 1
2{
3    void Eat();
4}
5
6interface IMammal // Interface 2
7{
8    void Walk();
9}
10
11class Dog : IAnimal, IMammal // Implementing multiple interfaces
12{
13    public void Eat()
14    {
15        Console.WriteLine("Eating...");
16    }
17
18    public void Walk()
19    {
20        Console.WriteLine("Walking...");
21    }
22}
23
24class Program
25{
26    static void Main(string[] args)
27    {
28        Dog dog = new Dog();
29        dog.Eat(); // Implemented from IAnimal
30        dog.Walk(); // Implemented from IMammal
31    }
32}

5. Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance. C# does not support hybrid inheritance directly due to the ambiguity it can create. However, it can be achieved through interfaces.

Example:

csharp
1interface IAnimal
2{
3    void Eat();
4}
5
6interface IMammal
7{
8    void Walk();
9}
10
11class Animal // Base class
12{
13    public void Sleep()
14    {
15        Console.WriteLine("Sleeping...");
16    }
17}
18
19class Dog : Animal, IAnimal, IMammal // Derived class
20{
21    public void Eat()
22    {
23        Console.WriteLine("Eating...");
24    }
25
26    public void Walk()
27    {
28        Console.WriteLine("Walking...");
29    }
30}
31
32class Program
33{
34    static void Main(string[] args)
35    {
36        Dog dog = new Dog();
37        dog.Eat(); // From IAnimal
38        dog.Walk(); // From IMammal
39        dog.Sleep(); // From Animal
40    }
41}

Benefits of using Inheritance

csharp
1class Animal
2{
3    public void Eat() { Console.WriteLine("Eating..."); }
4}
5
6class Dog : Animal
7{
8    public void Bark() { Console.WriteLine("Barking..."); }
9}
10// Dog can use the Eat method without redefining it.

csharp
1class Animal
2{
3    public virtual void Speak() { Console.WriteLine("Animal speaks"); }
4}
5
6class Dog : Animal
7{
8    public override void Speak() { Console.WriteLine("Dog barks"); }
9}

csharp
1class Animal { }
2class Mammal : Animal { }
3class Bird : Animal { }
4class Dog : Mammal { }

csharp
1class Animal
2{
3    protected void Sleep() { /* Implementation */ }
4}
5class Dog : Animal
6{
7    public void Rest() { Sleep(); } // Dog can access Sleep method
8}

csharp
1Animal myAnimal = new Dog();
2myAnimal.Speak(); // Calls Dog's Speak method if overridden