Open/Closed Principle (OCP)

What is the Open/Closed Principle?

The Open/Closed Principle (OCP) is the second principle in the SOLID design principles. It states:

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

This means that the behavior of a module can be extended without modifying its source code. This principle helps in writing code that is resilient to change and easy to scale.

Why is OCP Important?

• Enhances software flexibility and maintainability.
• Promotes code reuse through polymorphism and inheritance.
• Reduces the risk of bugs when modifying existing code.

Violation of OCP

Let’s consider a simple example that violates the Open/Closed Principle:

public class AreaCalculator {
    public double CalculateArea(object shape) {
        if (shape is Circle) {
            Circle c = (Circle)shape;
            return Math.PI * c.Radius * c.Radius;
        } else if (shape is Rectangle) {
            Rectangle r = (Rectangle)shape;
            return r.Width * r.Height;
        }
        return 0;
    }
}

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

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

Issue: Every time a new shape is introduced (e.g., Triangle), the AreaCalculator class needs to be modified, violating the OCP.

How to Fix the Violation?

Use polymorphism and interfaces/abstract classes to make the system open for extension but closed for modification:

public interface IShape {
    double CalculateArea();
}

public class Circle : IShape {
    public double Radius { get; set; }
    public double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : IShape {
    public double Width { get; set; }
    public double Height { get; set; }
    public double CalculateArea() {
        return Width * Height;
    }
}

public class AreaCalculator {
    public double CalculateArea(IShape shape) {
        return shape.CalculateArea();
    }
}

Benefit: Now, if you add a new shape (e.g., Triangle), you don't need to change the AreaCalculator. Just implement the IShape interface.

Benefits of Applying OCP

• Extensibility: Easily add new behavior without changing existing code.
• Stability: Reduces the chances of introducing bugs into tested code.
• Testability: Encourages writing decoupled, testable code components.

Conclusion

The Open/Closed Principle helps build systems that are flexible and adaptable to change. It emphasizes the importance of designing systems that accommodate new features via extension rather than risky modifications to existing logic.