C#面向对象设计模式纵横谈 学习笔记20 Chain of Responsibility职责链模式(行为型模式)

本文介绍职责链模式在软件开发中的应用,旨在降低请求发送者与接收者的耦合度。通过构造处理器链,使得请求能够在链上依次传递,直到被某个处理器处理。此模式提高了对象职责分配的灵活性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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

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

  1. public abstract class BaseHandler
  2.     {
  3.         public BaseHandler(BaseHandler next)
  4.         {
  5.             this.next = next;
  6.         }
  7.         
  8.         public virtual void HandleRequest(Request request)
  9.         {
  10.             if(next != null)
  11.             {
  12.                 this.next.HandleRequest(request);
  13.             }
  14.         }
  15.         public abstract bool CanHandleRequest();
  16.        
  17.         
  18.         private BaseHandler next;
  19.         
  20.         public BaseHandler Next
  21.         {
  22.             get
  23.             {
  24.                 return this.next;
  25.             }
  26.             set
  27.             {
  28.                 this.next = value;
  29.             }
  30.         }
  31.     }
  32.     
  33.     public class AHandler : BaseHandler
  34.     {
  35.         public AHandler(BaseHandler next) : base(next)
  36.         {
  37.         }
  38.         
  39.         public override void HandleRequest(Request request)
  40.         {
  41.             if(this.CanHandleRequest())
  42.             {
  43.                 //处理
  44.             }
  45.             else
  46.             {
  47.                 base.HandleRequest(request);
  48.             }
  49.         }
  50.         public override bool CanHandleRequest()
  51.         {
  52.             return false;
  53.         }
  54.     }
  55.     
  56.     public class BHandler : BaseHandler
  57.     {
  58.         public BHandler(BaseHandler next) : base(next)
  59.         {
  60.         }
  61.         
  62.         public override void HandleRequest(Request request)
  63.         {
  64.             if(this.CanHandleRequest())
  65.             {
  66.                 //处理
  67.             }
  68.             else
  69.             {
  70.                 base.HandleRequest(request);
  71.             }
  72.         }
  73.         public override bool CanHandleRequest()
  74.         {
  75.             return true;
  76.         }
  77.     }
  78.     
  79.     public class CHandler : BaseHandler
  80.     {
  81.         public CHandler(BaseHandler next) : base(next)
  82.         {
  83.         }
  84.         
  85.         public override void HandleRequest(Request request)
  86.         {
  87.             if(this.CanHandleRequest())
  88.             {
  89.                 //处理
  90.             }
  91.             else
  92.             {
  93.                 base.HandleRequest(request);
  94.             }
  95.         }
  96.         public override bool CanHandleRequest()
  97.         {
  98.             return true;
  99.         }
  100.     }
  101.     
  102.     public class Request
  103.     {
  104.     }
  105.     
  106.     public class Sender
  107.     {
  108.         public void Process(BaseHandler handler)
  109.         {
  110.             Request request = new Request();
  111.             
  112.             
  113.             
  114.             handler.HandleRequest(request);
  115.             
  116.             //ArrayList list = new ArrayList();
  117.             //list.Add(new AHandler());
  118.             //list.Add(new BHandler());
  119.             //list.Add(new CHandler());
  120.             
  121.             //foreach(BaseHandler handler in list)
  122.             //{
  123.             //    if(handler.CanHandleRequest())
  124.             //    {
  125.             //        handler.HandleRequest(request);
  126.             //    }
  127.             //}
  128.         }
  129.     }
  130.     
  131.     class Program
  132.     {
  133.         static void Main(string[] args)
  134.         {
  135.             Sender sender = new Sender();
  136.             BaseHandler handler1 = new AHandler(null);
  137.             BaseHandler handler2 = new BHandler(handler1);
  138.             BaseHandler handler3 = new CHandler(handler2);
  139.             
  140.             sender.Process(handler3);
  141.         }
  142.     }

可以看到上面的代码,我们抽象出来BaseHandler类,作为处理类的基类,类里有一个虚方法HandleRequest,实现为将请求交个下一个Handler去处理,还有一个纯虚方法CanHandleRequest,用来判断是否当前Handler能否处理请求。next作为一个引用(指针)用来保存下一个处理器的地址。我们设计的思路就是构造一个像链表的处理器链,通过next指针连接起来。那么继承BaseHandler的A、B、C三个handler重写了CanHandleRequest和HandleRequest方法,CanHandleRequest方法用来判断当前Handler能否处理消息,HandleRequest方法首先判断当前Handler能否处理,如果能处理就自己处理,如果不能处理就交给下一个Handler处理。在Main函数里,我们实例化三个Handler,并且将他们链接起来。

要点:

Chain of Responsibility模式的应用场合在于一个请求可能有多个接受者,但是最后真正的接受者只有一个,只有这个时候请求发送者与接受者的耦合才可能出现变化脆弱的症状,职责链的目的就是将两者解藕,从而更好的应对变化。
应用了Chain of Resposibility模式后,对象的职责分派将更具有灵活性,我们可以在运行时动态添加/修改请求的处理职责,就是说我们可以动态的给职责链里插入Handler
如果请求传递到职责链的末尾仍得不到处理,应该有一个合理的缺省机制,这也是每一个接受对象的责任,而不是发出请求的对象的责任。
我们可以将职责链看作一个由很多小Handler组成的大Handler,他可以随时添加小的Handler,可以有默认处理的Handler,并且可以根据各种不同的条件来将消息给不同的小Handler处理。
但在windows消息循环中,没有用到职责链模式,因为消息循环需要快速的响应,并且,消息循环的消息种类太多,如果消息种类组成的职责链会相当的庞大,那么整个消息循环的机制会非常缓慢

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值