Mastering Polymorphism in C#

Polymorphism is a fundamental concept in object-oriented programming (OOP) that enables methods to behave differently based on the object they are invoked upon. In C#, polymorphism allows a single interface to represent multiple underlying forms (data types), enhancing code flexibility and reusability.

Key Concepts

• Definition: Polymorphism, meaning 'many shapes', permits methods to operate on objects of various classes as if they were instances of a common superclass.
• Types of Polymorphism:
  • Compile-time Polymorphism (Static Binding): Resolved at compile time through method overloading and operator overloading.
  • Run-time Polymorphism (Dynamic Binding): Resolved at runtime via method overriding, typically utilizing virtual methods.

Compile-time Polymorphism

• Method Overloading: This involves having the same method name with different parameters.

Example:

class MathOperations
{
    public int Add(int a, int b) { return a + b; }
    public double Add(double a, double b) { return a + b; }
}

Run-time Polymorphism

• Method Overriding: This occurs when a derived class defines a method with the same name and signature as a method in its base class.
• Using Polymorphism:
  • You can invoke the overridden methods using a base class reference.

Example:

Animal myDog = new Dog();
Animal myCat = new Cat();

myDog.Sound(); // Output: Dog barks
myCat.Sound(); // Output: Cat meows

Example:

class Animal
{
    public virtual void Sound() { Console.WriteLine("Animal makes a sound"); }
}

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

class Cat : Animal
{
    public override void Sound() { Console.WriteLine("Cat meows"); }
}

Benefits of Polymorphism

• Flexibility: Enables you to write code at the superclass level, easing maintenance and scalability.
• Code Reusability: Minimizes code duplication by allowing the same method name to exhibit different behaviors based on the object type.

Conclusion

Polymorphism is a powerful feature in C# that enhances code flexibility and reusability. By mastering compile-time and run-time polymorphism, developers can create more dynamic and adaptable applications.