Open-Closed Principle

Back to: Software Development Principles

The Open-Closed Principle: A Guide with C# Examples

The Open-Closed Principle (OCP) is one of the five SOLID principles of object-oriented design. It was introduced by Bertrand Meyer in 1988 and is a key principle for writing maintainable and extensible software. The OCP states that software entities (classes, modules, functions) should be open for extension but closed for modification. In other words, you should be able to add new functionality to a system without changing the existing code.

Understanding the Open-Closed Principle

To better understand the OCP, let’s break it down:

Open for Extension: This means that you should be able to add new features or functionalities to your software without altering the existing codebase. You should be able to extend the behavior of a class or module through inheritance or composition rather than modification.
Closed for Modification: Once a class or module is designed and implemented, it should not be changed to accommodate new requirements. Existing code should remain untouched. Any changes or enhancements should be implemented by creating new classes or modules.

Example with C# Code

Consider a scenario where you have a system that calculates the area of different shapes like rectangles and circles. Without adhering to the OCP, your code might look like this:

public class AreaCalculator
{
    public double CalculateArea(object shape)
    {
        if (shape is Rectangle)
        {
            var rectangle = (Rectangle)shape;
            return rectangle.Width * rectangle.Height;
        }
        else if (shape is Circle)
        {
            var circle = (Circle)shape;
            return Math.PI * Math.Pow(circle.Radius, 2);
        }
        // More shapes...
        return 0;
    }
}

This code violates the OCP because every time you want to add a new shape (e.g., a triangle), you need to modify the AreaCalculator class, which is closed for modification.

To adhere to the OCP, you can use polymorphism and create an abstract base class (Shape) and derived classes (Rectangle and Circle) for each shape:

public abstract class Shape
{
    public abstract double CalculateArea();
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public override double CalculateArea()
    {
        return Width * Height;
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public override double CalculateArea()
    {
        return Math.PI * Math.Pow(Radius, 2);
    }
}

Now, you can extend your system by creating new classes that inherit from the Shape base class, without modifying the existing code.

public class Triangle : Shape
{
    public double Base { get; set; }
    public double Height { get; set; }

    public override double CalculateArea()
    {
        return 0.5 * Base * Height;
    }
}

By adhering to the OCP, you’ve created a system that is open for extension but closed for modification. You can add new shapes by creating new classes that inherit from Shape, without changing the existing code in the AreaCalculator.

Benefits of the Open-Closed Principle

Maintainability: The OCP promotes code that is easier to maintain because you don’t have to modify existing code when adding new features.
Extensibility: It allows for the easy addition of new functionality by creating new classes or modules that adhere to existing interfaces or abstract classes.
Reduced Risk: Modifying existing code can introduce bugs or unintended consequences. The OCP reduces the risk associated with code changes.
Parallel Development: Multiple developers can work on extending the system concurrently without conflicts.

In conclusion, the Open-Closed Principle is a fundamental concept in object-oriented design that encourages the creation of flexible, extensible, and maintainable software. By adhering to the OCP, you can build systems that are ready for future enhancements while minimizing the risks associated with code modifications.

Stay Connected