Open/Closed Principle (OCP)

Definition

Software entities should be:

  • Open for extension
  • Closed for modification

👉 You should be able to add new functionality without changing existing code.

Purpose

  • Prevent breaking existing code
  • Improve scalability
  • Reduce bugs during changes
  • Make systems extensible
  • Follow clean architecture principles

Bad Example ❌


public class TaxCalculator
{
    public decimal Calculate(string type, decimal amount)
    {
        if(type == "GST")
        {
            return amount * 0.18m;
        }
        else if(type == "NoTax")
        {
            return 0;
        }

        return 0;
    }
}

Problem

Whenever new tax type comes:

  • InternationalTax
  • ServiceTax
  • ExportTax

👉 Existing code must be modified repeatedly.

This can:

  • Introduce bugs
  • Break old functionality
  • Increase complexity

Good Example ✅

Step 1: Abstraction


public interface ITaxStrategy
{
    decimal Calculate(decimal amount);
}

Step 2: Concrete Implementations

GST Tax


public class GstTax : ITaxStrategy
{
    public decimal Calculate(decimal amount)
    {
        return amount * 0.18m;
    }
}

No Tax


public class NoTax : ITaxStrategy
{
    public decimal Calculate(decimal amount)
    {
        return 0;
    }
}

International Tax


public class InternationalTax : ITaxStrategy
{
    public decimal Calculate(decimal amount)
    {
        return amount * 0.25m;
    }
}

Step 3: Use Abstraction


public class InvoiceService
{
    private readonly ITaxStrategy _taxStrategy;

    public InvoiceService(ITaxStrategy taxStrategy)
    {
        _taxStrategy = taxStrategy;
    }

    public decimal GetTotal(decimal amount)
    {
        return amount + _taxStrategy.Calculate(amount);
    }
}

Usage Example


var invoice =
    new InvoiceService(new GstTax());

Console.WriteLine(invoice.GetTotal(1000));

Output


1180

Key Concept

Instead of:

Modify existing if-else code

We do:

Add new strategy class

👉 Existing code remains untouched.

Real-Time Scenario

Payment System:

  • UPI Payment
  • Credit Card
  • Net Banking
  • Wallet Payment

👉 Add new payment methods without changing old code.

Advantages

  • ✔ Easier extension
  • ✔ Reduced bugs
  • ✔ Better scalability
  • ✔ Cleaner architecture
  • ✔ Safer code changes

Disadvantages

  • ✖ More interfaces/classes
  • ✖ Slight complexity increase
  • ✖ Over-engineering for small apps

When to Use

Use OCP when:

  • Business rules change frequently
  • New features added regularly
  • System needs scalability
  • Large if-else conditions appear

Real Project Mapping (.NET + Angular)

Feature OCP Usage
Payment providers OCP
Tax calculation OCP
Authentication methods OCP
File export formats OCP
Notification providers OCP

ASP.NET Core Real Example

Authentication providers:

  • JWT
  • Google
  • Facebook
  • OAuth

👉 New providers added without modifying framework core.

OCP vs SRP

OCP SRP
Extend without modification One responsibility
Focus on scalability Focus on responsibility
Avoid changing old code Avoid mixed responsibilities

Pro Tip

OCP works best with:

  • Strategy Pattern
  • Factory Pattern
  • Dependency Injection
  • Plugin architectures

Summary

OCP helps you:

  • Extend applications safely
  • Reduce modification risk
  • Build scalable systems

👉 Perfect for:

  • Enterprise applications
  • Payment systems
  • APIs
  • Plugin-based architectures

Comments

Post a Comment

Popular posts from this blog

Promises in Angular

🚀 Promises in Angular – The Complete Beginner’s Guide (with Examples) 📘 Introduction In modern Angular development, handling asynchronous operations is essential. Whether you're fetching data from an API, loading files, or wrapping browser-native APIs, Promises offer a clean and readable way to deal with one-time asynchronous operations. This guide explains: What Promises are How they compare with Observables Real-world examples using .then() and async/await When to use Promises vs Observables in Angular 📚 Table of Contents 🔍 What is a Promise? 🔁 Promise Lifecycle ✨ Key Features 📌 Syntax 💻 Example 1: Fetch 💻 Example 2: setTimeout 📊 Promises vs Observables 🎯 When to Use Promises 📦 Angular Service Example 🔄 Observable vs Promise ❓ FAQ ✅ Summary 🔍 What is a Promise? A Promise is a JavaScript object that represents the eventual success (fulfilled) or failure (rejected) of an asynchronous operation. 📌 Com...
Read more

Debouncing & Throttling in RxJS: Optimizing API Calls and User Interactions

RxJS Debounce vs Throttle in Angular – Best Practices & Examples What is RxJS — quick primer RxJS (Reactive Extensions for JavaScript) provides Observables and operators to model and manipulate streams of asynchronous events — from keystrokes and HTTP requests to timers and WebSocket messages. 💡 Why this matters: Operators like debounceTime and throttleTime help you control event frequency, reducing wasted CPU and network work while improving UX. 1. Debouncing — emit after silence Debouncing delays emitting a value until a specified period of inactivity. It's best for typeahead inputs where only the final value after the user stops typing is relevant. Live search example (production-ready) // search.component.ts import { Component, OnDestroy } from '@angular/core'; import { FormControl } from '@angular/forms'; import { Subject } from 'rxjs'; import { debounc...
Read more

Csharp Coding - Session

Image
✅ Reverse String Array using System; public class Program { public static void Main() { ReverseStringArray (); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; int length = str.Length; for (int i = 0, j = length - 1; i < j; i++, j--) { string temp = str[i]; str[i] = str[j]; str[j] = temp; } Console.WriteLine(string.Join(", ", str)); // Output: Sai, priya } } Output: Sai, priya ✅ Reverse String Array + Each Word using System; public class Program { public static void Main() { ReverseStringArray(); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; // Step 1: Reverse the array string[] reversedArray = ReverseArray (str); // Step 2: Reverse e...
Read more