Overview

Polymorphism is a core concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms (data types). In .NET, polymorphism is crucial because it enhances flexibility and maintainability, allowing for dynamic method binding and more generic programming approaches.

Key Concepts

1. Static Polymorphism (Compile-time): Achieved through method overloading.
2. Dynamic Polymorphism (Run-time): Implemented using method overriding through inheritance and interfaces.
3. Virtual and Override Keywords: Key to implementing dynamic polymorphism in C#.

Common Interview Questions

Basic Level

1. What is polymorphism and why is it important in C#?
2. Can you show a simple example of polymorphism in C#?

Intermediate Level

3. How does polymorphism work with inheritance and interfaces in C#?

Advanced Level

4. Describe a scenario where polymorphism can lead to better software design in .NET applications.

Detailed Answers

1. What is polymorphism and why is it important in C#?

Answer: Polymorphism, a fundamental concept in OOP, enables objects of different classes to be treated as objects of a common superclass. It's important in C# for creating flexible and easily maintainable code as it lets a single method call to act on objects of different classes. Polymorphism enhances the reusability of code and makes it easier to scale and modify applications.

Key Points:
- Enables objects to be treated as instances of their parent class rather than their actual class.
- Simplifies code management and expansion.
- Facilitates the implementation of interface-based programming.

Example:

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

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

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

public class Program
{
    static void Main()
    {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.Speak();  // Outputs: Bark
        myCat.Speak();  // Outputs: Meow
    }
}

2. Can you show a simple example of polymorphism in C#?

Answer: Yes, polymorphism can be illustrated through method overriding, where a base class method is overridden in a derived class using the override keyword.

Key Points:
- Base class method must be marked virtual or abstract.
- Derived class method uses the override keyword.
- Allows derived classes to provide a specific implementation of a method that is already provided by its base class.

Example:

public class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        // Draw a circle
        Console.WriteLine("Drawing a circle");
    }
}

public class Square : Shape
{
    public override void Draw()
    {
        // Draw a square
        Console.WriteLine("Drawing a square");
    }
}

public class Program
{
    static void Main()
    {
        Shape shape = new Circle();
        shape.Draw();  // Outputs: Drawing a circle

        shape = new Square();
        shape.Draw();  // Outputs: Drawing a square
    }
}

3. How does polymorphism work with inheritance and interfaces in C#?

Answer: In C#, polymorphism works with inheritance by allowing derived classes to override base class methods, providing their specific implementations. With interfaces, it allows different classes to implement the same interface in different ways, thus enabling them to be treated uniformly through the interface type.

Key Points:
- Inheritance enables polymorphism through method overriding.
- Interfaces allow for polymorphism without inheriting from a specific class.
- Both mechanisms enable objects to be treated polymorphically.

Example:

public interface IShape
{
    void Draw();
}

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

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

public class Program
{
    static void Main()
    {
        IShape shape = new Circle();
        shape.Draw();  // Drawing a circle

        shape = new Square();
        shape.Draw();  // Drawing a square
    }
}

4. Describe a scenario where polymorphism can lead to better software design in .NET applications.

Answer: Polymorphism shines in scenarios where multiple classes share a common set of behaviors but implement them differently. For instance, in a graphic editor, different shapes (circles, squares, etc.) need to be drawn, but each has its own drawing logic. By implementing a common interface (e.g., IDrawable) or using a base class with a virtual method Draw, the application can treat all shapes uniformly, enhancing code reusability and flexibility. This approach simplifies adding new shapes without modifying existing drawing logic or the application's core functionalities.

Key Points:
- Promotes code reusability by using a common interface or base class.
- Enhances flexibility by allowing the introduction of new classes with minimal changes to existing code.
- Simplifies maintenance and scalability of the application.

Example:

public interface IDrawable
{
    void Draw();
}

public class Circle : IDrawable
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

public class Square : IDrawable
{
    public void Draw()
    {
        Console.WriteLine("Drawing a square");
    }
}

public class GraphicEditor
{
    public void DrawShape(IDrawable shape)
    {
        shape.Draw();
    }
}

public class Program
{
    static void Main()
    {
        var editor = new GraphicEditor();
        editor.DrawShape(new Circle()); // Drawing a circle
        editor.DrawShape(new Square()); // Drawing a square
    }
}