Chain of Responsibility Pattern-优快云博客

MFC 提供了消息的处理的链式处理策略基本就是使用这种模式。

participants

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

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