Chain of Responsibility Design Pattern
 |
Avoid coupling the sender of a request to its receiver by
giving more than one object a chance to handle the request. Chain the
receiving objects and pass the request along the chain until an object
handles it.
Frequency of use:  medium low
|
|
 |
The classes and/or objects participating in this pattern are:
- Handler (Approver)
- defines an interface for handling the requests
- (optional) implements the successor link
- ConcreteHandler (Director, VicePresident, President)
- handles requests it is responsible for
- can access its successor
- if the ConcreteHandler can handle the request, it does so; otherwise it forwards the request to its successor
- Client (ChainApp)
- initiates the request to a ConcreteHandler object on the chain
This structural code demonstrates the Chain of Responsibility pattern in which several linked
objects (the Chain) are offered the opportunity to respond to a request or hand it
off to the object next in line.
Show code
|
// Chain of Responsibility pattern -- Structural example
|
|
using System;
namespace DoFactory.GangOfFour.Chain.Structural
{
// MainApp test application
class MainApp
{
static void Main()
{
// Setup Chain of Responsibility
Handler h1 = new ConcreteHandler1();
Handler h2 = new ConcreteHandler2();
Handler h3 = new ConcreteHandler3();
h1.SetSuccessor(h2);
h2.SetSuccessor(h3);
// Generate and process request
int[] requests = {2, 5, 14, 22, 18, 3, 27, 20};
foreach (int request in requests)
{
h1.HandleRequest(request);
}
// Wait for user
Console.Read();
}
}
// "Handler"
abstract class Handler
{
protected Handler successor;
public void SetSuccessor(Handler successor)
{
this.successor = successor;
}
public abstract void HandleRequest(int request);
}
// "ConcreteHandler1"
class ConcreteHandler1 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 0 && request < 10)
{
Console.WriteLine("{0} handled request {1}",
this.GetType().Name, request);
}
else if (successor != null)
{
successor.HandleRequest(request);
}
}
}
// "ConcreteHandler2"
class ConcreteHandler2 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 10 && request < 20)
{
Console.WriteLine("{0} handled request {1}",
this.GetType().Name, request);
}
else if (successor != null)
{
successor.HandleRequest(request);
}
}
}
// "ConcreteHandler3"
class ConcreteHandler3 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 20 && request < 30)
{
Console.WriteLine("{0} handled request {1}",
this.GetType().Name, request);
}
else if (successor != null)
{
successor.HandleRequest(request);
}
}
}
}
|
Output
ConcreteHandler1 handled request 2
ConcreteHandler1 handled request 5
ConcreteHandler2 handled request 14
ConcreteHandler3 handled request 22
ConcreteHandler2 handled request 18
ConcreteHandler1 handled request 3
ConcreteHandler3 handled request 27
ConcreteHandler3 handled request 20
|
This real-world code demonstrates the Chain of Responsibility pattern in which several linked
managers and executives can respond to a purchase request
or hand it off to a superior. Each position has can have its own set of rules
which orders they can approve.
Show code
|
// Chain of Responsibility pattern -- Real World example
|
|
using System;
namespace DoFactory.GangOfFour.Chain.RealWorld
{
// MainApp test application
class MainApp
{
static void Main()
{
// Setup Chain of Responsibility
Director Larry = new Director();
VicePresident Sam = new VicePresident();
President Tammy = new President();
Larry.SetSuccessor(Sam);
Sam.SetSuccessor(Tammy);
// Generate and process purchase requests
Purchase p = new Purchase(2034, 350.00, "Supplies");
Larry.ProcessRequest(p);
p = new Purchase(2035, 32590.10, "Project X");
Larry.ProcessRequest(p);
p = new Purchase(2036, 122100.00, "Project Y");
Larry.ProcessRequest(p);
// Wait for user
Console.Read();
}
}
// "Handler"
abstract class Approver
{
protected Approver successor;
public void SetSuccessor(Approver successor)
{
this.successor = successor;
}
public abstract void ProcessRequest(Purchase purchase);
}
// "ConcreteHandler"
class Director : Approver
{
public override void ProcessRequest(Purchase purchase)
{
if (purchase.Amount < 10000.0)
{
Console.WriteLine("{0} approved request# {1}",
this.GetType().Name, purchase.Number);
}
else if (successor != null)
{
successor.ProcessRequest(purchase);
}
}
}
// "ConcreteHandler"
class VicePresident : Approver
{
public override void ProcessRequest(Purchase purchase)
{
if (purchase.Amount < 25000.0)
{
Console.WriteLine("{0} approved request# {1}",
this.GetType().Name, purchase.Number);
}
else if (successor != null)
{
successor.ProcessRequest(purchase);
}
}
}
// "ConcreteHandler"
class President : Approver
{
public override void ProcessRequest(Purchase purchase)
{
if (purchase.Amount < 100000.0)
{
Console.WriteLine("{0} approved request# {1}",
this.GetType().Name, purchase.Number);
}
else
{
Console.WriteLine(
"Request# {0} requires an executive meeting!",
purchase.Number);
}
}
}
// Request details
class Purchase
{
private int number;
private double amount;
private string purpose;
// Constructor
public Purchase(int number, double amount, string purpose)
{
this.number = number;
this.amount = amount;
this.purpose = purpose;
}
// Properties
public double Amount
{
get{ return amount; }
set{ amount = value; }
}
public string Purpose
{
get{ return purpose; }
set{ purpose = value; }
}
public int Number
{
get{ return number; }
set{ number = value; }
}
}
}
|
Output
Director Larry approved request# 2034
President Tammy approved request# 2035
Request# 2036 requires an executive meeting!
|
This .NET optimized code demonstrates the
same real-world situation as above but uses modern, built-in .NET features.
Show code
|
// Chain of Responsibility pattern -- .NET optimized
|
See our Singleton page for a .NET optimized code sample.
|
|
|