• 设计模式——链接模式

    名称 Chain of Responsibility
    结构  
    意图 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
    适用性
    • 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
    • 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
    • 可处理一个请求的对象集合应被动态指定。
    Code Example
      1// Chain Of Responsibility
      2
      3// Intent: "Avoid coupling the sender of a request to its receiver by giving 
      4// more than one object a chance to handle the reuqest. Chain the receiving 
      5// objects and pass the request along the chain until an object handles it." 
      6
      7// For further information, read "Design Patterns", p223, Gamma et al.,
      8// Addison-Wesley, ISBN:0-201-63361-2
      9
     10/* Notes:
     11 * The client sends a request and it will be operated on by one of a number 
     12 * of potential receivers, in a chain. The client does not know (and does 
     13 * not need to know) which receiver handles the request. The receivers are
     14 * in a chain, and the request is passed from one to the next, until one 
     15 * receiver actually performs the request. 
     16 */
     17 
     18namespace ChainOfResponsibility_DesignPattern
     19{
     20    using System;
     21
     22    abstract class Handler 
     23    {
     24        protected Handler successorHandler;
     25        abstract public void HandleRequest(Request request);        
     26        public void SetSuccessor(Handler sucessor)
     27        {
     28            successorHandler = sucessor;
     29        }
     30    }
     31
     32    class ConcreteHandler1 : Handler
     33    {
     34        override public void HandleRequest(Request request)
     35        {
     36            // determine if we can handle the request
     37            if (request.RequestType == 1) // some complex decision making!
     38            {
     39                // request handling code goes here
     40                Console.WriteLine("request handled in ConcreteHandler1");
     41            }
     42            else 
     43            {
     44                // not handled here - pass on to next in the chain
     45                if (successorHandler != null)
     46                    successorHandler.HandleRequest(request);
     47            }
     48        }
     49    }
     50
     51    class ConcreteHandler2 : Handler
     52    {
     53        override public void HandleRequest(Request request)
     54        {
     55            // determine if we can handle the request
     56            if (request.RequestType == 2) // some complex decision making!
     57            {
     58                // request handling code goes here
     59                Console.WriteLine("request handled in ConcreteHandler2");
     60            }
     61            else 
     62            {
     63                // not handled here - pass on to next in the chain
     64                if (successorHandler != null)
     65                    successorHandler.HandleRequest(request);
     66            }
     67        }
     68    }
     69
     70    class ConcreteHandler3 : Handler
     71    {
     72        override public void HandleRequest(Request request)
     73        {
     74            // determine if we can handle the request
     75            if (request.RequestType == 3) // some complex decision making!
     76            {
     77                // request handling code goes here
     78                Console.WriteLine("request handled in ConcreteHandler3");
     79            }
     80            else 
     81            {
     82                // not handled here - pass on to next in the chain
     83                if (successorHandler != null)
     84                    successorHandler.HandleRequest(request);
     85            }            
     86        }
     87    }
     88
     89    class Request 
     90    {
     91        private int iRequestType;
     92        private string strRequestParameters;
     93
     94        public Request(int requestType, string requestParameters)
     95        {
     96            iRequestType = requestType;    
     97            strRequestParameters = requestParameters;
     98        }
     99
    100        public int RequestType 
    101        {
    102            get 
    103            {
    104                return iRequestType;
    105            }
    106            set 
    107            {
    108                iRequestType = value;
    109            }
    110        }
    111    }
    112
    113    /// <summary>
    114    ///    Summary description for Client.
    115    /// </summary>
    116    public class Client
    117    {
    118        public static int Main(string[] args)
    119        {
    120            // Set up chain (usually one need to be done once)
    121            Handler firstHandler = new ConcreteHandler1();
    122            Handler secondHandler = new ConcreteHandler2();
    123            Handler thirdHandler = new ConcreteHandler3();
    124            firstHandler.SetSuccessor(secondHandler);
    125            secondHandler.SetSuccessor(thirdHandler);
    126
    127            // After setting up the chain of responsibility, we can
    128            // now generate requests and pass then off to the 
    129            // chain to be handled
    130
    131            // generate and fire request
    132            Request newRequest = new Request(2,"This are the request parameters");
    133            firstHandler.HandleRequest(newRequest);
    134            
    135            return 0;
    136        }
    137    }
    138}
    139
    140
  • 相关阅读:
    nginx安装http2.0协议
    nginx内置变量 大全
    nginx全局查看进程
    Nginx1.14.2新增tcp/udp代理stream
    Nginx Location指令配置及常用全局变量
    Nginx配置udp/tcp代理
    ps -ef|grep详解
    centos7安装nginx（基础篇）
    js转义字符
    redis win连接以及配置连接密码
  • 原文地址：https://www.cnblogs.com/DarkAngel/p/206198.html
Copyright © 2020-2023  润新知