设计模式学习之路——Chain Of Responsibility 职责链模式

     请求的发送者和接受者可能存在如下关系，某些对象的请求的接受者可能多种多样，变化无常，职责链（Chain Of Responsibility）模式允许多个类处理同一个请求，而不需要了解彼此的功能。它在类之间提供了一种松散的耦合：类之间唯一的联系就是相互传递的请求。请求在类之间传递，直到其中一个类处理它为止。

动机：

在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。

如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。

意图：

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

结构：

代码实现

using System;
using System.Collections.Generic;
using System.Text;

namespace ChainOfResponsibility
{
    class Program
    {
        static void Main(string[] args)
        {
            ClientSender client = new ClientSender();
            BaseHandler SuTankHandler = new SuTank(null);
            BaseHandler USATankHandler = new USATank(SuTankHandler);
            BaseHandler SuFighterHandler = new SuFighter(USATankHandler);
            BaseHandler USAFighterHandler = new USAFighter(SuFighterHandler);

            client.Process(USAFighterHandler, Sender.SuFighter, Command.Attack); 
            client.Process(USAFighterHandler, Sender.USATank, Command.Stop);  

            Console.ReadKey();
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public enum Command
    {
        Attack, //进攻
        Stop    //撤退
    }
    public enum Sender
    {
        SuTank,    //苏联坦克
        USATank,    //美国坦克
        SuFighter,  //苏联飞机
        USAFighter  //美国飞机
    }


    public class Request
    {
        public Request(Command _cmd, Sender _sender)
        {
            this.cmd = _cmd;
            this.sender = _sender;

        }

        private Command cmd;

        public Command Cmd
        {
            get { return cmd; }
            set { cmd = value; }
        }

        private Sender sender;

        public Sender Sender
        {
            get { return sender; }
            set { sender = value; }
        }


    }

    public abstract class BaseHandler
    {
        public BaseHandler(BaseHandler _next)
        {
            this.Next = _next;
        }

        protected abstract bool CanHandlerRequest(Request request);

        public virtual void HandlerRequest(Request request)
        {
            if (this.next != null)
            {
                this.next.HandlerRequest(request);
            }
        }

        private BaseHandler next;

        public BaseHandler Next
        {
            get { return this.next; }
            set { this.next = value; }
        }
    }

    public class SuTank : BaseHandler
    {
        public SuTank(BaseHandler next)
            : base(next)
        {

        }
        protected override bool CanHandlerRequest(Request request)
        {
            if (request.Sender == Sender.SuTank)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public override void HandlerRequest(Request request)
        {
            if (this.CanHandlerRequest(request))
            {
                if (request.Cmd == Command.Attack)
                {
                    Console.WriteLine("Su坦克进攻！");
                }
                else if (request.Cmd == Command.Stop)
                {
                    Console.WriteLine("Su坦克撤退！");
                }
            }
            else
            {
                base.HandlerRequest(request);
            }
        }


    }

    public class SuFighter : BaseHandler
    {
        public SuFighter(BaseHandler next)
            : base(next)
        {

        }
        protected override bool CanHandlerRequest(Request request)
        {
            if (request.Sender == Sender.SuFighter)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public override void HandlerRequest(Request request)
        {
            if (this.CanHandlerRequest(request))
            {
                if (request.Cmd == Command.Attack)
                {
                    Console.WriteLine("Su飞机进攻！");
                }
                else if (request.Cmd == Command.Stop)
                {
                    Console.WriteLine("Su飞机撤退！");
                }
            }
            else
            {
                base.HandlerRequest(request);
            }
        }


    }

    public class USATank : BaseHandler
    {
        public USATank(BaseHandler next)
            : base(next)
        {

        }
        protected override bool CanHandlerRequest(Request request)
        {
            if (request.Sender == Sender.USATank)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public override void HandlerRequest(Request request)
        {
            if (this.CanHandlerRequest(request))
            {
                if (request.Cmd == Command.Attack)
                {
                    Console.WriteLine("USA坦克进攻！");
                }
                else if (request.Cmd == Command.Stop)
                {
                    Console.WriteLine("USA坦克撤退！");
                }
            }
            else
            {
                base.HandlerRequest(request);
            }
        }
    }

    public class USAFighter : BaseHandler
    {
        public USAFighter(BaseHandler next)
            : base(next)
        {

        }
        protected override bool CanHandlerRequest(Request request)
        {
            if (request.Sender == Sender.USAFighter)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public override void HandlerRequest(Request request)
        {
            if (this.CanHandlerRequest(request))
            {
                if (request.Cmd == Command.Attack)
                {
                    Console.WriteLine("USA飞机进攻！");
                }
                else if (request.Cmd == Command.Stop)
                {
                    Console.WriteLine("USA飞机撤退！");
                }
            }
            else
            {
                base.HandlerRequest(request);
            }
        }
    }


    public class ClientSender
    {
        public void Process(BaseHandler handler, Sender sender,Command cmd)
        {
            Request request = new Request(cmd, sender);
            handler.HandlerRequest(request);
        }
    }


}

Chain of Responsibility模式的几个要点

1.Chain of Responsibility 模式的应用场合在于“一个请求可能有多个接受者，但是最后真正的接受者只有一个”，只有这时候请求发送者与接受者的耦合才有可能出现“变化脆弱”的症状，职责链的目的就是将二者解耦，从而更好地应对变化。

3.应用了Chain of Responsibility 模式后，对象的职责分派将更具灵活性。我们可以在运行时动态添加/修改请求的处理职责。

4.如果请求传递到职责链的末尾仍得不到处理，应该有一个合理的缺省机制。这也是每一个接受对象的责任，而不是发出请求的对象的责任