When to Use Abstract Classes in C#

Short Answer

You use an abstract class in C# when you want to create a base class that provides some common functionality but also requires derived classes to implement specific methods. Abstract classes cannot be instantiated on their own and are used to define a blueprint for other classes.

Detailed Explanation with Examples

What is an Abstract Class in C#?

An abstract class in C# is a special type of class that cannot be instantiated directly. Instead, it serves as a base or template for other classes. It can contain both complete methods (with implementation) and abstract methods (without implementation). Derived classes must provide implementations for the abstract methods.

When to Use an Abstract Class?

You should use an abstract class in the following scenarios:

1. To Provide a Common Base

Abstract classes are ideal when you want to define a common structure or behavior for a group of related classes. For example, if you are building a system that deals with different shapes (like circles, rectangles, etc.), you can create an abstract class called Shape that contains common properties and methods.

2. To Enforce Implementation

Abstract classes can include abstract methods, which act as a contract for derived classes. These methods must be implemented by any class that inherits from the abstract class. For instance, if every shape must calculate its area, you can define an abstract method CalculateArea() in the Shape class. Derived classes like Circle and Rectangle will then provide their own implementations for this method.

3. To Enable Polymorphism

Abstract classes allow you to treat objects of derived classes as objects of the base class. This is called polymorphism. For example, you can create a list of Shape objects and store different shapes like circles and rectangles in it. You can then call the CalculateArea() method on each shape without knowing its specific type.

4. To Provide Incomplete Implementation

Abstract classes can have both abstract and non-abstract methods. This means you can provide some default behavior while leaving other methods to be implemented by derived classes. For example, the Shape class might have a default method Display() that prints "This is a shape," but leave CalculateArea() as an abstract method to be implemented by derived classes.

Example: Using an Abstract Class in C#

Let’s look at an example to understand how abstract classes work in practice.

// Abstract class
abstract class Shape
{
    // Abstract method (must be implemented by derived classes)
    public abstract double CalculateArea();

    // Non-abstract method (default implementation)
    public void Display()
    {
        Console.WriteLine("This is a shape.");
    }
}

// Derived class: Circle
class Circle : Shape
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    // Implementation of the abstract method
    public override double CalculateArea()
    {
        return Math.PI * radius * radius;
    }
}

// Derived class: Rectangle
class Rectangle : Shape
{
    private double length;
    private double width;

    public Rectangle(double length, double width)
    {
        this.length = length;
        this.width = width;
    }

    // Implementation of the abstract method
    public override double CalculateArea()
    {
        return length * width;
    }
}

// Main program
class Program
{
    static void Main()
    {
        // Create objects of derived classes
        Circle circle = new Circle(5);
        Rectangle rectangle = new Rectangle(4, 6);

        // Use methods from the abstract class
        circle.Display();
        Console.WriteLine("Circle Area: " + circle.CalculateArea());

        rectangle.Display();
        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
    }
}

Explanation of the Example

1. Abstract Class (Shape):
   • The Shape class is declared as abstract, meaning it cannot be instantiated directly.
   • It contains an abstract method CalculateArea() that must be implemented by any derived class.
   • It also includes a non-abstract method Display() with a default implementation.
2. Derived Classes (Circle and Rectangle):
   • Both Circle and Rectangle inherit from the Shape class.
   • They provide their own implementations for the CalculateArea() method.
   • They can also use the Display() method inherited from the Shape class.
3. Polymorphism in Action:
   • In the Main method, we create objects of Circle and Rectangle and treat them as Shape objects.
   • This allows us to call the CalculateArea() method on each object without knowing its specific type.

Key Takeaways

• Use an abstract class when you want to define a common base with shared functionality.
• Abstract classes enforce derived classes to implement specific methods.
• They enable polymorphism, allowing you to write flexible and reusable code.
• Abstract classes can provide both complete and incomplete implementations.

By using abstract classes, you can create a well-structured and maintainable codebase that adheres to the principles of object-oriented programming.