loader

Chain Of Responsibility – The Easiest Explanation Ever

Application ArchitectureGang of FourWeb Development

Ever called tech support and been passed from one agent to another until someone finally fixes your problem? That’s exactly what the Chain of Responsibility Pattern is all about—it creates a hotline of handlers where each one gets a chance to deal with a request. If one can’t help, the call gets forwarded to the next in line until your issue is resolved.

Why Bother with It?

  • Smooth Escalation: Just like tech support, your request is handled by the right expert without overwhelming a single person or component.
  • Decoupled Request Handling: Each handler only cares about its own expertise. If it can’t solve your problem, it passes it on—no one gets bogged down.
  • Flexibility and Reusability: Easily add or remove support levels without rewriting your entire help desk (or code). The chain remains intact even as your system grows.

How It Works (In Plain English)

  1. The Call Center Setup: Think of your system as a call center with multiple support levels (Level 1, Level 2, Level 3, etc.).
  2. Handling the Call: When a request comes in, it goes to the first support agent. If they can handle it, great! If not, they pass it to the next available agent.
  3. Escalation on Demand: The request keeps moving along the chain until it reaches an agent who can resolve the issue—or it goes unhandled if no one can help.
  4. No Overlap, Just Efficiency: Each agent deals with their specific type of problem, keeping the process neat and efficient.

C# Code Example

C#
using System;

// Handler interface: Defines a method for setting the next handler and handling the request.
public interface ITechSupport
{
    ITechSupport SetNext(ITechSupport handler);
    void HandleRequest(string issue);
}

// Base class for common functionality
public abstract class TechSupportBase : ITechSupport
{
    private ITechSupport _nextHandler;

    public ITechSupport SetNext(ITechSupport handler)
    {
        _nextHandler = handler;
        return handler;
    }

    public virtual void HandleRequest(string issue)
    {
        if (_nextHandler != null)
        {
            _nextHandler.HandleRequest(issue);
        }
        else
        {
            Console.WriteLine("Issue could not be resolved. Please try again later.");
        }
    }
}

// Level One Support: Handles basic issues.
public class LevelOneSupport : TechSupportBase
{
    public override void HandleRequest(string issue)
    {
        if (issue.Contains("password") || issue.Contains("login"))
        {
            Console.WriteLine("Level One: Issue handled - " + issue);
        }
        else
        {
            base.HandleRequest(issue);
        }
    }
}

// Level Two Support: Handles intermediate issues.
public class LevelTwoSupport : TechSupportBase
{
    public override void HandleRequest(string issue)
    {
        if (issue.Contains("crash") || issue.Contains("error"))
        {
            Console.WriteLine("Level Two: Issue handled - " + issue);
        }
        else
        {
            base.HandleRequest(issue);
        }
    }
}

// Level Three Support: Handles advanced issues.
public class LevelThreeSupport : TechSupportBase
{
    public override void HandleRequest(string issue)
    {
        Console.WriteLine("Level Three: Issue handled - " + issue);
    }
}

// Client Code
public class Program
{
    public static void Main()
    {
        // Set up the chain of responsibility
        ITechSupport levelOne = new LevelOneSupport();
        ITechSupport levelTwo = new LevelTwoSupport();
        ITechSupport levelThree = new LevelThreeSupport();
        levelOne.SetNext(levelTwo).SetNext(levelThree);
        
        // Different issues coming into the system
        Console.WriteLine("Request 1: 'Forgot my password'");
        levelOne.HandleRequest("Forgot my password");
        
        Console.WriteLine("\nRequest 2: 'Application crash on startup'");
        levelOne.HandleRequest("Application crash on startup");
        
        Console.WriteLine("\nRequest 3: 'Unknown system failure'");
        levelOne.HandleRequest("Unknown system failure");
    }
}

The Takeaway

The Chain of Responsibility Pattern is like having a well-organized tech support hotline. Each level handles what it’s best at, passing on the call until someone can resolve the issue. This design keeps your code decoupled and flexible—just like a smooth escalation process in a customer support center. Next time you need to manage a series of handlers, think of your own tech support hotline and let the chain do its magic!

Happy coding—and may your issues always be handled efficiently!