Mingbo

在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。

意图

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

结构图

职责链模式在其内部实现了一个自我的链式结构，采用了和Decorator 模式一样的方法，不但继承了自己，还要包含自己。下面的代码，模拟了一个公司处理订单的业务逻辑，多少金额内，什么级别的人可以处理。

代码

using System;

namespace Chain_of_Responsibility
{
    class Program
    {
        static void Main(string[] args)
        {
            Purchase p = new Purchase(2012,9678.89,"Diamond For Women");
            President president = new President();
            VicePresident vicepresident = new VicePresident("Nobody-Care", president);
            Director director = new Director("Impp", vicepresident);

            director.ProcessRequest(p);
            p = new Purchase(2013, 159678.00, "Car For Women");
            director.ProcessRequest(p);
            p = new Purchase(2014, 459678.00, "House For Women");
            director.ProcessRequest(p);
        }
    }
    class Purchase {
        private int _number;

        public int Number
        {
            get { return _number; }
            set { _number = value; }
        }
        private double _amount;

        public double Amount
        {
            get { return _amount; }
            set { _amount = value; }
        }
        private string _purpose;

        public string Purpose
        {
            get { return _purpose; }
            set { _purpose = value; }
        }

        public Purchase(int number,double amount,string purpose) {
            this._amount = amount;
            this._number = number;
            this._purpose = purpose;
        }
    }

    abstract class Approver {
        protected Approver _successor;

        internal Approver Successor
        {
            get { return _successor; }
            set { _successor = value; }
        }
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public Approver(string name,Approver successor) {
            this._name = name;
            this._successor = successor;
        }

        public virtual void ProcessRequest(Purchase p) {
            if (this._successor != null) {
                this._successor.ProcessRequest(p);
            }
        }

    }

    class Director : Approver {
        public Director(string name, Approver successor) : base(name, successor) { }
        public Director() : base("Director", null) { }
        public override void ProcessRequest(Purchase p)  {
            if (p.Amount < 10000) {
                Console.WriteLine("{0} approved reqest #{1}",this.GetType().Name,p.Number);
            }
            else
                base.ProcessRequest(p);
        }
    }

    class VicePresident : Approver {
        public VicePresident(string name, Approver successor) : base(name, successor) { }
        public VicePresident() : base("Director", null) { }
        public override void ProcessRequest(Purchase p) {
            if(p.Amount<200000){
                Console.WriteLine("{0} approved reqest #{1}", this.GetType().Name, p.Number);
            }
            else
                base.ProcessRequest(p);
        }
    }

    class President : Approver {
        public President(string name, Approver successor) : base(name, successor) { }
        public President() : base("Director", null) { }
        public override void ProcessRequest(Purchase p)  {
            if (p.Amount < 500000) {
                Console.WriteLine("{0} approved reqest #{1}", this.GetType().Name, p.Number);
            }
            else
                Console.WriteLine("Request #{0} needs an excutive meeting!",p.Number);
        }
    }
}

运行结果