Design Pattern----16.Behavioral.Chain of Responsibility.Pattern

Intent

• 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.
• Launch-and-leave requests with a single processing pipeline that contains many possible handlers.
• An object-oriented linked list with recursive traversal.

Problem

There is a potentially variable number of “handler” or “processing element” or “node” objects, and a stream of requests that must be handled. Need to efficiently process the requests without hard-wiring handler relationships and precedence, or request-to-handler mappings.

Discussion

Encapsulate the processing elements inside a “pipeline” abstraction; and have clients “launch and leave” their requests at the entrance to the pipeline.

 

The pattern chains the receiving objects together, and then passes any request messages from object to object until it reaches an object capable of handling the message. The number and type of handler objects isn’t known a priori, they can be configured dynamically. The chaining mechanism uses recursive composition to allow an unlimited number of handlers to be linked.

 

Chain of Responsibility simplifies object interconnections. Instead of senders and receivers maintaining references to all candidate receivers, each sender keeps a single reference to the head of the chain, and each receiver keeps a single reference to its immediate successor in the chain.

 

Make sure there exists a “safety net” to “catch” any requests which go unhandled.

 

Do not use Chain of Responsibility when each request is only handled by one handler, or, when the client object knows which service object should handle the request.

Structure

The derived classes know how to satisfy Client requests. If the “current” object is not available or sufficient, then it delegates to the base class, which delegates to the “next” object, and the circle of life continues.

 

Multiple handlers could contribute to the handling of each request. The request can be passed down the entire length of the chain, with the last link being careful not to delegate to a “null next”.

Example

The Chain of Responsibility pattern avoids coupling the sender of a request to the receiver by giving more than one object a chance to handle the request. ATM use the Chain of Responsibility in money giving mechanism.

Check list

1. The base class maintains a “next” pointer.
2. Each derived class implements its contribution for handling the request.
3. If the request needs to be “passed on”, then the derived class “calls back” to the base class, which delegates to the “next” pointer.
4. The client (or some third party) creates and links the chain (which may include a link from the last node to the root node).
5. The client “launches and leaves” each request with the root of the chain.
6. Recursive delegation produces the illusion of magic.

Rules of thumb

• Chain of Responsibility, Command, Mediator, and Observer, address how you can decouple senders and receivers, but with different trade-offs. Chain of Responsibility passes a sender request along a chain of potential receivers.
• Chain of Responsibility can use Command to represent requests as objects.
• Chain of Responsibility is often applied in conjunction with Composite. There, a component’s parent can act as its successor.

Chain of Responsibility in C#

Avoids 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.

 

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.

  1: using System;

  2: 

  3:   class MainApp

  4:   {

  5:     static void Main()

  6:     {

  7:       // Setup Chain of Responsibility 

  8:       Handler h1 = new ConcreteHandler1();

  9:       Handler h2 = new ConcreteHandler2();

 10:       Handler h3 = new ConcreteHandler3();

 11:       h1.SetSuccessor(h2);

 12:       h2.SetSuccessor(h3);

 13: 

 14:       // Generate and process request 

 15:       int[] requests = {2, 5, 14, 22, 18, 3, 27, 20};

 16: 

 17:       foreach (int request in requests)

 18:       {

 19:         h1.HandleRequest(request);

 20:       }

 21: 

 22:       // Wait for user 

 23:       Console.Read();

 24:     }

 25:   }

 26: 

 27:   // "Handler" 

 28:   abstract class Handler 

 29:   {

 30:     protected Handler successor;

 31: 

 32:     public void SetSuccessor(Handler successor)

 33:     {

 34:       this.successor = successor;

 35:     }

 36: 

 37:     public abstract void HandleRequest(int request);

 38:   }

 39: 

 40:   // "ConcreteHandler1" 

 41:   class ConcreteHandler1 : Handler

 42:   {

 43:     public override void HandleRequest(int request)

 44:     {

 45:       if (request >= 0 && request < 10)

 46:       {

 47:         Console.WriteLine("{0} handled request {1}", 

 48:           this.GetType().Name, request);

 49:       }

 50:       else if (successor != null)

 51:       {

 52:         successor.HandleRequest(request);

 53:       }

 54:     }

 55:   }

 56: 

 57:   // "ConcreteHandler2" 

 58:   class ConcreteHandler2 : Handler

 59:   {

 60:     public override void HandleRequest(int request)

 61:     {

 62:       if (request >= 10 && request < 20)

 63:       {

 64:         Console.WriteLine("{0} handled request {1}", 

 65:           this.GetType().Name, request);

 66:       }

 67:       else if (successor != null)

 68:       {

 69:         successor.HandleRequest(request);

 70:       }

 71:     }

 72:   }

 73: 

 74:   // "ConcreteHandler3" 

 75:   class ConcreteHandler3 : Handler

 76:   {

 77:     public override void HandleRequest(int request)

 78:     {

 79:       if (request >= 20 && request < 30)

 80:       {

 81:         Console.WriteLine("{0} handled request {1}", 

 82:           this.GetType().Name, request);

 83:       }

 84:       else if (successor != null)

 85:       {

 86:         successor.HandleRequest(request);

 87:       }

 88:     }

 89:   }

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