Complete C# Tutorial

leafMan illustration
Updated on March 26, 2025

Mastering Inheritance in C# – A Beginner’s Guide!

Hey there, coder! 👋 Have you ever wondered how you can reuse code instead of writing the same thing over and over? Well, that’s where inheritance in C# comes to the rescue! 🚀

Inheritance is one of the core pillars of Object-Oriented Programming (OOP), allowing a class to inherit properties and behaviors from another class. Sounds cool, right? But wait… what does that even mean? 🤔

Imagine you’re designing a vehicle system. You have cars, bikes, and trucks. Instead of writing separate code for each vehicle’s speed, color, and engine, wouldn’t it be awesome if all these could share common properties? That’s the power of inheritance in C#! 💡

🎯 What is Inheritance in C#?

Inheritance means one class (child class) gets the properties and behaviors of another class (parent class).

Think of it like a family 👨‍👩‍👦. A child inherits certain traits from their parents. Similarly, a class in C# can inherit attributes and methods from another class.

 

📝 Syntax of Inheritance in C#

				
					class ParentClass  // Base class
{
    // Properties and methods that will be inherited
}

class ChildClass : ParentClass  // Derived class
{
    // Child class automatically gets properties/methods of ParentClass
}

💡 Key Points to Remember:

✅ The parent class (also called base class) holds common properties and methods.
✅ The child class (also called derived class) inherits everything from the parent class.
✅ The : symbol means “inherits from“.

🚀 Why Do We Use Inheritance in OOP?

✅ Code Reusability – No need to rewrite the same properties/methods in multiple classes.
✅ Better Organization – Helps maintain a clear class hierarchy.
✅ Easier Maintenance – If we update the base class, all derived classes get the update.
✅ Extensibility – New classes can be created based on existing ones, making the code flexible.

🎯 Simple Example: Implementing Inheritance in C#

Let’s see how inheritance in C# works with an easy example!

				
					using System;

// Base class (Parent)
class Vehicle  
{  
    public int Speed;  
    public string Color;  

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

// Derived class (Child)
class Car : Vehicle  
{  
    public string Model;  
}  

class Program  
{  
    static void Main()  
    {  
        Car myCar = new Car();  
        myCar.Speed = 120;  
        myCar.Color = "Red";  
        myCar.Model = "Tesla";  

        Console.WriteLine($"Car Model: {myCar.Model}, Speed: {myCar.Speed} km/h, Color: {myCar.Color}");  
        myCar.StartEngine();  
    }  
}
🖥️ Output:
				
					Car Model: Tesla, Speed: 120 km/h, Color: Red  
Engine started! 🚗💨

🔥 Key Takeaways:

✅ We only wrote Speed, Color, and StartEngine() once in Vehicle, but Car can still use them!
✅ We extended the Vehicle class without modifying it.
✅ Inheritance saves time, reduces code duplication, and makes programs easy to maintain.

🧐 How Inheritance is Used Here

1️⃣ Creating a Parent Class (Vehicle)

				
					class Vehicle  
{  
    public int Speed;  
    public string Color;  

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

What’s happening here?

  • We created a class Vehicle, which represents a generic vehicle.
  • It has two properties (Speed and Color).
  • It has one method StartEngine(), which prints "Engine started!".

Think of Vehicle as a general blueprint for all vehicles! 🚙🚲🚚

2️⃣ Creating a Child Class (Car)

				
					class Car : Vehicle  
{  
    public string Model;  
}

What’s happening here?

  • The Car class inherits from Vehicle using the : symbol (class Car : Vehicle).
  • This means Car automatically gets the Speed, Color, and StartEngine() from Vehicle.
  • We added a new property Model that is specific to Car.

🚀 This is inheritance in action! The Car class now has everything a Vehicle has, plus some extra features.

 

3️⃣ Using Inheritance in the Main() Method

				
					Car myCar = new Car();  
myCar.Speed = 120;  
myCar.Color = "Red";  
myCar.Model = "Tesla";  

Console.WriteLine($"Car Model: {myCar.Model}, Speed: {myCar.Speed} km/h, Color: {myCar.Color}");  
myCar.StartEngine();

What’s happening here?

  1. We create a Car object: Car myCar = new Car();
  2. We set its inherited properties (Speed and Color).
  3. We set the Model (which belongs only to Car).
  4. We print all the details.
  5. We call myCar.StartEngine();, which is inherited from Vehicle!

🔥 More Examples to Understand Inheritance in C#

 

Example 2: Employee Hierarchy

Let’s say we have a company with different employees like managers and developers. But all employees share common details like name and salary.

				
					using System;

// Base class (Parent)
class Employee  
{  
    public string Name;  
    public double Salary;  

    public void Work()  
    {  
        Console.WriteLine($"{Name} is working! 💼");  
    }  
}  

// Derived class (Child)
class Developer : Employee  
{  
    public string ProgrammingLanguage;  
}  

class Program  
{  
    static void Main()  
    {  
        Developer dev = new Developer();  
        dev.Name = "Alice";  
        dev.Salary = 70000;  
        dev.ProgrammingLanguage = "C#";  

        Console.WriteLine($"{dev.Name} earns ${dev.Salary} and codes in {dev.ProgrammingLanguage}");  
        dev.Work();  
    }  
}
🖥️ Output:
				
					Alice earns $70000 and codes in C#  
Alice is working! 💼

🚀 Explanation

  • Banking System → Base class Account, derived classes SavingsAccount & CurrentAccount.
  • Gaming → Base class Character, derived classes Warrior, Mage, Archer.
  • E-Commerce → Base class Product, derived classes Electronics, Clothing, Furniture.

⚠️ Advantages & Disadvantages of Inheritance

 

✅ Advantages

✔️ Saves time – No need to rewrite code.
✔️ Organized structure – Clear class hierarchy.
✔️ Easier updates – Changes in base class affect all derived classes.

 

❌ Disadvantages

⚠️ Can make debugging tricky – A bug in the base class affects all child classes.
⚠️ Overuse can lead to complexity – Deep inheritance chains make maintenance hard.
⚠️ Not always the best choice – Sometimes, composition (using objects instead of inheritance) is better.

 

🔥 Conclusion

So, now you know what inheritance in C# is and why it’s so powerful! 🚀

  • It helps us reuse code, organize classes, and make changes easily.
  • We explored real-world examples like vehicles and employees.
  • We also learned about its advantages and disadvantages.

But wait… how do we actually implement inheritance in real-world projects? 🤔

 

🚀 Next What?

In the next lesson, we’ll dive deeper into Implementing Inheritance in C# with advanced examples and best practices!

Excited? Let’s keep learning and coding! 💡🔥

← OOPs – Inheritance
base, virtual, override, and new keyword →

Leave a Comment

Share this Doc

Inheritance in C#

Or copy link