设计模式学习笔记——职责链模式（Chain of Responsibility）

1.特点：将处理者排成链，沿链传递请求。（单请求，多处理）

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

3.类图：

4.程序实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace 职责链模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //设置职责链上家与下家
            Handler h1 = new ConcreteHandler1();
            Handler h2 = new ConcreteHandler2();
            Handler h3 = new ConcreteHandler3();
            h1.SetSuccessor(h2);
            h2.SetSuccessor(h3);
 
            int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };
            foreach (int request in requests)
            {
               //循环给最小处理着提交请求，不同的数据由不同权限处理者处理
                h1.HandleRequest(request);
            }
            Console.Read();
        }
    }
     
    //Handler类，定义一个处理请示的接口
    abstract class Handler
    {
        protected Handler successor;
 
        //设置继任者
        public void SetSuccessor(Handler successor)
        {
            this.successor = successor;
        }
         //处理请求的抽象方法
        public abstract void HandleRequest(int request);
    }
        
     
        //ConcreteHandler类，具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理该请求就处理它，否则就将该请求转发给它的后继者
 
        //ConcreteHandler1类，当请求数在0到10之间则有权处理，否则转到下一位
        class ConcreteHandler1:Handler 
        {
            public override void HandleRequest(int request)
            {
                if (request >= 0 && request < 10)
                {
                    Console.WriteLine("{0}处理请求{1}", this.GetType ().Name , request);
 
                }
                else if (successor != null)
                {
                    //转移到下一位
                    successor.HandleRequest(request);
             
                }
            }
         }
     
        //ConcreteHandler2类，当请求数在10到20之间则有权处理，否则转到下一位
 
        class ConcreteHandler2 : Handler
        {
            public override void HandleRequest(int request)
            {
                if (request >= 10 && request < 20)
                {
                    Console.WriteLine("{0}处理请求{1}", this.GetType().Name, request);
                }
                else if (successor != null)
                {
                    successor.HandleRequest(request);
                }
            }
        }
 
       //ConcreteHandler3类，当请求数在20到30之间则有权处理，否则转到下一位
        class ConcreteHandler3 : Handler
        {
            public override void HandleRequest(int request)
            {
                if (request >= 20 && request < 30)
                {
                    Console.WriteLine("{0}处理请求{1}", this.GetType().Name, request);
                }
                else if (successor != null)
                {
                    successor.HandleRequest(request);
                }
            }
        }
         
    }