Chain of Responsibility Pattern in C# – Real-Time Example (Request Processing Pipeline)

What is Chain of Responsibility Pattern?

The Chain of Responsibility Pattern is a behavioral design pattern where a request is passed through a chain of handlers until one handler processes it.

Each handler:

  • Processes the request
  • Or passes it to the next handler

👉 Creates a pipeline-like structure.

Why Use Chain of Responsibility Pattern?

  • Reduce tight coupling
  • Build flexible processing pipelines
  • Dynamically add/remove handlers
  • Separate responsibilities cleanly
  • Avoid large if-else chains

Real-Time Scenario

API Request Pipeline:

  • Authentication
  • Authorization
  • Validation
  • Logging

👉 Request passes through multiple handlers sequentially.

Real-Time Example – Request Validation Pipeline

Step 1: Abstract Handler


public abstract class Handler
{
    protected Handler _nextHandler;

    public void SetNext(Handler nextHandler)
    {
        _nextHandler = nextHandler;
    }

    public abstract void Handle(string request);
}

Step 2: Concrete Handlers

Authentication Handler


public class AuthenticationHandler : Handler
{
    public override void Handle(string request)
    {
        Console.WriteLine("Authentication Successful");

        _nextHandler?.Handle(request);
    }
}

Validation Handler


public class ValidationHandler : Handler
{
    public override void Handle(string request)
    {
        Console.WriteLine("Validation Successful");

        _nextHandler?.Handle(request);
    }
}

Logging Handler


public class LoggingHandler : Handler
{
    public override void Handle(string request)
    {
        Console.WriteLine("Request Logged");

        _nextHandler?.Handle(request);
    }
}

Step 3: Build the Chain


var auth = new AuthenticationHandler();
var validation = new ValidationHandler();
var logging = new LoggingHandler();

auth.SetNext(validation);
validation.SetNext(logging);

auth.Handle("Create Invoice Request");

Output


Authentication Successful
Validation Successful
Request Logged

Key Concept

Instead of:


Authenticate();
Validate();
Log();

We do:


auth.Handle(request);

👉 Request flows through handler chain.

Diagram Understanding


Request
   ↓
AuthenticationHandler
   ↓
ValidationHandler
   ↓
LoggingHandler

👉 Each handler processes and forwards request.

Advantages

  • ✔ Loose coupling
  • ✔ Flexible processing pipeline
  • ✔ Easy to add/remove handlers
  • ✔ Better separation of concerns
  • ✔ Cleaner request processing

Disadvantages

  • ✖ Harder debugging
  • ✖ Request may go unhandled
  • ✖ Too many handlers can increase complexity

When to Use

Use Chain of Responsibility when:

  • Multiple handlers process requests
  • Request pipeline is needed
  • Dynamic processing flow is required
  • Responsibilities should be separated

Real Project Mapping (.NET + Angular)

Feature Usage
Middleware pipeline Chain of Responsibility
Validation pipeline Chain of Responsibility
Logging pipeline Chain of Responsibility
Approval workflow Chain of Responsibility
Request processing Chain of Responsibility

ASP.NET Core Real Example

Middleware Pipeline


app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints();

👉 ASP.NET Core middleware internally follows Chain of Responsibility.

Advanced Example – Approval Workflow


Employee Request
      ↓
Manager Approval
      ↓
HR Approval
      ↓
Finance Approval

👉 Each stage processes request sequentially.

Chain of Responsibility vs Mediator

Chain of Responsibility Mediator
Request flows sequentially Centralized communication
Multiple handlers process request Mediator coordinates objects
Pipeline-oriented Interaction-oriented

Pro Tip

Chain of Responsibility works well with:

  • Middleware
  • Validation frameworks
  • Logging systems
  • Workflow engines
  • CQRS pipelines

Summary

Chain of Responsibility helps you:

  • Build flexible pipelines
  • Separate request processing logic
  • Reduce tight coupling

👉 Perfect for:

  • Middleware
  • Validation
  • Approval workflows
  • Request processing systems

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