Open/Closed Principle in C#

In the world of software design, the Open/Closed Principle is one of the five SOLID principles of object-oriented programming. It ensures your code is easy to extend and maintain while reducing the risk of introducing bugs. Let’s break it down and explore how to implement it in C#.

What is the Open/Closed Principle?

The Open/Closed Principle (OCP) states:

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

In simpler terms:

• Open for extension: You should be able to add new functionality without altering existing code.
• Closed for modification: Once a class or module is written, you shouldn’t need to change its core functionality to meet new requirements.

By adhering to this principle, you reduce the likelihood of breaking existing functionality when adding new features.

Why Follow the Open/Closed Principle?

Imagine a scenario where every new feature requires you to edit multiple existing classes. This could:

• Introduce new bugs.
• Make the code harder to understand and maintain.
• Slow down development as the system grows.

The OCP helps avoid these issues by encouraging a design where new behavior is added without touching existing code.

How to Implement OCP in C#?

The key to implementing OCP is polymorphism. Instead of modifying existing classes, you create new classes that implement or extend existing behavior.

Let’s look at an example.

Example: A Simple Notification System

Problem:

You have a notification system that sends email notifications. Now, you want to extend it to support SMS notifications.

Without OCP, you might write something like this:

public class NotificationService
{
    public void SendNotification(string message, string type)
    {
        if (type == "Email")
        {
            Console.WriteLine("Sending Email: " + message);
        }
        else if (type == "SMS")
        {
            Console.WriteLine("Sending SMS: " + message);
        }
    }
}        

Issues:

1. Every time you add a new notification type (e.g., push notifications), you must modify this class by adding else if code block.
2. This violates the Open/Closed Principle since the class isn’t closed for modification.

Solution: Use Interfaces and Polymorphism

Let’s refactor the code to follow OCP.

1. Create an interface for notifications:

public interface INotification
{
    void Send(string message);
}        

2. Implement specific notification types:

public class EmailNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine("Sending Email: " + message);
    }
}        

public class SMSNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine("Sending SMS: " + message);
    }
}        

3. Modify the NotificationService to use the interface:

public class NotificationService
{
    private readonly List<INotification> _notifications;

    public NotificationService()
    {
        _notifications = new List<INotification>();
    }

    public void AddNotification(INotification notification)
    {
        _notifications.Add(notification);
    }

    public void Notify(string message)
    {
        foreach (var notification in _notifications)
        {
            notification.Send(message);
        }
    }
}        

4. Use the new system:

class Program
{
    static void Main(string[] args)
    {
        var notificationService = new NotificationService();

        notificationService.AddNotification(new EmailNotification());
        notificationService.AddNotification(new SMSNotification());

        notificationService.Notify("Hello, world!");
    }
}        

Benefits of This Approach:

Extensibility:

• Adding a new notification type (e.g., push notifications) only requires creating a new class that implements INotification.
• No need to modify existing code.

Maintainability:

• The NotificationService class remains unchanged, making it less prone to bugs.

Scalability:

• This design can handle more notification types without becoming cluttered or complex.

Example: Implementing Discounts

You want to calculate discounts for customers based on their types (e.g., regular customers, premium customers). Later, you may want to introduce special discounts for seasonal offers or specific promotions.

Naive Implementation (Violating OCP)

Here’s a typical implementation without adhering to the Open/Closed Principle:

public class DiscountService
{
    public decimal CalculateDiscount(string customerType, decimal totalAmount)
    {
        if (customerType == "Regular")
        {
            return totalAmount * 0.1m; // 10% discount
        }
        else if (customerType == "Premium")
        {
            return totalAmount * 0.2m; // 20% discount
        }
        else
        {
            return 0; // No discount
        }
    }
}        

Issues:

1. Adding a new discount type requires modifying the CalculateDiscount method.
2. Every change increases the risk of introducing bugs.
3. The method becomes harder to maintain as more conditions are added.

Refactored Implementation (Following OCP)

To adhere to the Open/Closed Principle, let’s use polymorphism and strategy design pattern.

Step 1: Create an Interface for Discounts

Define a common interface for all discount strategies:

public interface IDiscountStrategy
{
    decimal Calculate(decimal totalAmount);
}        

Step 2: Implement Specific Discount Strategies

Create classes for each discount type:

public class RegularCustomerDiscount : IDiscountStrategy
{
    public decimal Calculate(decimal totalAmount)
    {
        return totalAmount * 0.1m; // 10% discount
    }
}        

public class PremiumCustomerDiscount : IDiscountStrategy
{
    public decimal Calculate(decimal totalAmount)
    {
        return totalAmount * 0.2m; // 20% discount
    }
}        

public class NoDiscount : IDiscountStrategy
{
    public decimal Calculate(decimal totalAmount)
    {
        return 0; // No discount
    }
}        

Step 3: Use the Discount Strategies in the Service

Now, the DiscountService class doesn’t need to know about the specific discount types. It just uses the appropriate strategy:

public class DiscountService
{
    private readonly IDiscountStrategy _discountStrategy;

    public DiscountService(IDiscountStrategy discountStrategy)
    {
        _discountStrategy = discountStrategy;
    }

    public decimal ApplyDiscount(decimal totalAmount)
    {
        return _discountStrategy.Calculate(totalAmount);
    }
}        

Step 4: Use the Refactored Code

Here’s how to use the new system:

class Program
{
    static void Main(string[] args)
    {
        decimal totalAmount = 1000;

        // Regular customer
        var regularDiscountService = new DiscountService(new RegularCustomerDiscount());
        Console.WriteLine("Regular Customer Discount: " + regularDiscountService.ApplyDiscount(totalAmount));

        // Premium customer
        var premiumDiscountService = new DiscountService(new PremiumCustomerDiscount());
        Console.WriteLine("Premium Customer Discount: " + premiumDiscountService.ApplyDiscount(totalAmount));

        // No discount
        var noDiscountService = new DiscountService(new NoDiscount());
        Console.WriteLine("No Discount: " + noDiscountService.ApplyDiscount(totalAmount));
    }
}        

Benefits of This Approach

Extensibility:

• Adding a new discount type (e.g., “SeasonalDiscount”) only requires creating a new class that implements IDiscountStrategy. No existing code needs modification.

Separation of Concerns:

• Each discount calculation is encapsulated in its own class, making the code easier to understand and maintain.

Scalability:

• This design can scale to accommodate many discount types without bloating any single class or method.

Adding a New Discount: Seasonal Discount

To add a new discount type, you simply create a new class:

public class SeasonalDiscount : IDiscountStrategy
{
    public decimal Calculate(decimal totalAmount)
    {
        return totalAmount * 0.15m; // 15% seasonal discount
    }
}        

And then use it:

var seasonalDiscountService = new DiscountService(new SeasonalDiscount());
Console.WriteLine("Seasonal Discount: " + seasonalDiscountService.ApplyDiscount(totalAmount));        

Key Takeaways

• The Open/Closed Principle ensures your code is easy to extend and maintain.
• By using interfaces and polymorphism, you can design systems where new features are added without modifying existing code.
• This approach promotes clean, modular, and maintainable code that reduces the risk of bugs during enhancements.

By embracing OCP, your codebase becomes more robust and easier to manage, especially as it grows.

A Practical Thought

In real-world applications, you’ll often combine the Open/Closed Principle with other SOLID principles like Dependency Inversion (to manage dependencies) and Interface Segregation (to avoid bloated interfaces). Together, these principles guide you toward a clean, modular, and scalable system.