---

🏗️ C# Polymorphism – One Interface, Multiple Behaviors

---

🧲 Introduction – Why Learn Polymorphism in C#?

Polymorphism is a key principle of object-oriented programming that allows you to treat different objects in a uniform way while enabling them to behave differently. In C#, polymorphism increases flexibility, maintainability, and scalability—especially in large systems and frameworks.

🎯 In this guide, you’ll learn:

• What polymorphism means in C#
• Types of polymorphism: compile-time and runtime
• How to use virtual/override and interfaces
• Practical examples and use cases

---

🔍 Core Concept – What is Polymorphism?

Polymorphism allows different types to be treated as the same base type, yet respond differently to the same method call. It supports the concept of “one interface, many implementations.”

---

🧠 Types of Polymorphism in C#

Type	Description	Example Keyword
Compile-time (Static)	Method overloading (same name, different args)	Overload
Runtime (Dynamic)	Method overriding via inheritance	virtual/override

---

🔁 Compile-Time Polymorphism – Method Overloading

class Calculator
{
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
}

📘 Use Case: Multiple methods with same name but different signatures.

---

🔄 Runtime Polymorphism – Method Overriding

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

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

Animal pet = new Dog();
pet.Speak();  // Output: Dog barks

📘 Use Case: Allow derived classes to override base functionality.

---

🧩 Polymorphism with Interfaces

interface IShape
{
    void Draw();
}

class Circle : IShape
{
    public void Draw() => Console.WriteLine("Drawing Circle");
}

class Square : IShape
{
    public void Draw() => Console.WriteLine("Drawing Square");
}

IShape shape = new Circle();
shape.Draw(); // Output: Drawing Circle

📘 Use Case: Define behavior contract without implementation.

---

📊 Comparison Table – Overloading vs Overriding

Feature	Overloading	Overriding
Type	Compile-time	Runtime
Signature	Must differ	Must match
Use Case	Multiple ways to perform similar task	Modify inherited behavior
Keyword	None (overload by signature)	virtual / override

---

💡 Best Practices & Tips

💡 Tip: Use polymorphism to write extensible, loosely-coupled code.

⚠️ Pitfall: Avoid excessive use of inheritance for polymorphism; prefer interfaces or abstract classes.

📘 Best Practice: Always mark overridden methods with the override keyword to avoid bugs and confusion.

---

🛠️ Real-World Use Cases

• 🧾 Invoice calculation systems (Invoice → RetailInvoice, WholesaleInvoice)
• 🎮 Game objects (Enemy, Player, NPC) implementing Update()
• 📦 UI rendering components (Control → Button, Label, etc.)
• 📈 Strategy design pattern (e.g., different payment methods)

---

📌 Summary – Recap & Next Steps

🧵 Key Takeaways:

• Polymorphism enables common interface, varied behavior.
• Use virtual and override for runtime polymorphism.
• Use method overloading for compile-time polymorphism.

⚙️ Real-world relevance: C# polymorphism powers framework extensibility, design patterns, and interface-driven APIs.

---

❓ FAQ Section

❓ What’s the difference between inheritance and polymorphism?
✅ Inheritance lets one class use code from another; polymorphism lets it modify or extend behavior dynamically.

---

❓ Can I override a method not marked as virtual?
✅ ❌ No. Only virtual, abstract, or override methods can be overridden.

---

❓ Is overloading a type of polymorphism?
✅ Yes. Overloading is compile-time polymorphism, while overriding is runtime.

---

❓ Can interfaces be used for polymorphism?
✅ Yes. Interfaces are the most flexible way to implement polymorphism across unrelated classes.

---

❓ What is the benefit of polymorphism?
✅ It allows code flexibility, maintainability, and the use of design patterns like Strategy, Factory, and Dependency Injection.

---

---

Share Now :