设计模式——职责链模式

初识

职责链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一个链，并沿着这条链传递该请求，直到有一个对象处理它为止。

结构

角色：

Handler类：定义一个处理请示的接口
ConcreteHandler类：处理它所负责的请求，可访问它的后继者，如果可处理该请求，就处理之，否则就将该请求转发给它的后继者

实现

在我们身边类似于职责链模式的有很多。在我们学习的过程中，遇到问题的话，首先，要解决肯定要先靠自己，通过自己思考去尝试解决；解决不了可以站在巨人肩膀上，利用搜索引擎等一系列办法；如果还解决不了，可以请教他人。
这其实就是一条职责链，沿着这条链将问题进行传递，直到有一个办法可以将它解决为止。下面看看如何实现这个职责链。

class Program
{
    static void Main(string[] args)
    {
        Yourself jiji = new Yourself("寄几");
        Search shousuo = new Search("瘦琐");
        Ask qinjiao = new Ask("秦叫");

        jiji.SetSuperior(shousuo);
        shousuo.SetSuperior(qinjiao);

        Solve solve = new Solve();
        solve.SolveType = "生活";
        solve.SolveContent = "早起";
        jiji.SolveApplications(solve);


        Solve solve1 = new Solve();
        solve1.SolveType = "学习";
        solve1.SolveContent = "学习设计模式";
        jiji.SolveApplications(solve1);

        Solve solve2 = new Solve();
        solve2.SolveType = "交流";
        solve2.SolveContent = "同学间交流";
        jiji.SolveApplications(solve2);

        Console.Read();
    }
}

class Solve
{
    private string solvetype;

    public string SolveType
    {
        get { return solvetype; }
        set { solvetype= value; }
    }

    private string solvecontent;

    public string SolveContent
    {
        get { return solvecontent; }
        set { solvecontent= value; }
    }
}

abstract class Way//解决方法类
{
    protected string name;

    protected Way superior;

    public Way(string name)
    {
        this.name = name;
    }

    public void SetSuperior(Way superior)
    {
        this.superior = superior;
    }

    abstract public void SolveApplications(Solve solve);
}

class Yourself: Way//自己类
{
    public Yourself(string name) : base(name)
    {

    }

    public override void SolveApplications(Solve solve)
    {
        if (solve.SolveType == "生活")
        {
            Console.WriteLine("{0}:解决{1}问题", name, solve.SolveContent);
        }
        else
        {
            if (superior!= null)
            {
                superior.SolveApplications(solve);
            }
        }
    }
}

class Search: Way//搜索类
{
    public Search(string name):base(name)
    {

    }

    public override void SolveApplications(Solve solve)
    {
        if (solve.SolveType == "学习")
        {
            Console.WriteLine("{0}:解决{1}问题", name, solve.SolveContent);
            
        }
        else
        {
            if (superior!=null)
            {
                superior.SolveApplications(solve);
            }
        }
    }
}

class Ask: Way//请教类
{
    public Ask(string name):base(name)
    {

    }
    public override void SolveApplications(Solve solve)
    {
        if (solve.SolveType == "交流")
        {
            Console.WriteLine("{0}:解决{1}问题", name, solve.SolveContent);
        }
        else
        {
            if (superior!=null)
            {
                superior.SolveApplications(solve);
            }
        }
    }
}

运行结果：

优点

• 接受者和发送者都没有对方的明确信息，且链中的对象也并不知道链的结构，结果是责任链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选继承者，大大的降低了耦合度。
  请求者不用管具体哪个对象会处理，反正该请求肯定会被处理就行了
• 可以随时增加或者修改处理一个请求的结构，增加了给对象指派职责的灵活性