大学IT网 - 最懂大学生的IT学习网站! QQ资料交流群:367606806
当前位置:大学IT网 > C#技巧 > C#之职责链模式

C#之职责链模式(2)

关键词:职责链模式C#  阅读(1202) 赞(19)

[摘要]本文是对C#之职责链模式的讲解,与大家分享。

 ComponentModel comModel = new ComponentModel();
 ConcreteHandlerCaseOne caseone = new ConcreteHandlerCaseOn(comModel);
 caseone.HandleRequest(RequestState.Check);
 ConcreteHandlerCaseTwo casetwo = new ConcreteHandlerCaseTw(comModel);
 casetwo.HandleRequest(RequestState.Check);

对的,就是这样,一次次的检测下去,如果要检测20次,并且都是不同的实现,那将非常可怕,代码冗余,而且请求调用方和处理方的耦合度也很大,那要怎么样让代码更精简,并且还能有效的解耦,这里就要用到职责链模式。

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

这里要强调一下的是本篇的示例中并没有完全遵从设计模式的定义,还是按照本文开始的功能需求来做的设计,当然了模式的核心不变。

设计模式的思想:

现在先对处理方进行抽象:

     /// <summary>
     /// 抽象处理者
    /// </summary>
     public abstract class Handle
     {
         protected Handle Successor;
         public void SetSuccessor(Handle successor)
         {
             this.Successor = successor;
         }
         public abstract void HandleRequest(RequestStatereqState,ComponentModel comModel);
 
     }

既然有了抽象,那就得有具体的实现:

 /// <summary>
     /// 具体处理者
     /// </summary>
     public class ConcreteHandlerA : Handle
     {
         public override void HandleRequest(RequestState reqState, ComponentModel comModel)
         {
             switch (reqState)
             {
                 case RequestState.Check:
                     //执行处理
 
                     break;
                 case RequestState.SetDefValue:
                     //执行处理
                     break;
                 default:
                     this.Successor.HandleRequest(reqState, comModel);
                     break;
 
             }
         }
     }
     /// <summary>
     /// 具体处理者
     /// </summary>
     public class ConcreteHandlerB : Handle
     {
         public override void HandleRequest(RequestState reqState, ComponentModel comModel)
         {
             switch (reqState)
             {
                 case RequestState.Check:
                     //执行处理
                     break;
                 case RequestState.SetDefValue:
                     //执行处理
                     break;
                 default:
                     this.Successor.HandleRequest(reqState, comModel);
                     break;
 
             }
         }
     }

这里的类型应该只定义一个的是为了让大家看的更明白。

在这里看抽象处理者Handle类型,它里面有个protected级别的变量Successor,Successor呢就代表着链表中每一环的指针,指向谁呢?当然是指向下一个处理者。
现在来看一下调用的代码:

 ComponentModel comModel = new ComponentModel();
 Handle handlerA = new ConcreteHandlerA();
 Handle handlerB = new ConcreteHandlerB();
 handlerA.SetSuccessor(handlerB);
 handlerA.HandleRequest(RequestState.Check, comModel);

看上去已经不错了,耦合度还是很大的,对于handlerA的调用,还是再调用方直接调用的,这时需要一个中间层,

看一下中间层的定义:

     /// <summary>
     /// ChainOfResponsibility模式帮助类
    /// </summary>
     public class CORUnit
     {
         private Handle _Handle;
 
         private ComponentModel _ComModel;
 
         public CORUnit(ComponentModel commodel)
             : this(null, commodel)
         {
             _ComModel = commodel;
         }
         public CORUnit(Handle Handle, ComponentModel commodel)
         {
             _Handle = Handle;
             _ComModel = commodel;
         }
         public void RegisterHandle(Handle handle)
         {
             if (_Handle != null)
             {
                 _Handle.SetSuccessor(handle);//指向 处理链中的下一个 处理模块
             }
             else
             {
                 _Handle = handle;
             }
         }
         public void HandleRequest(RequestState reqState)
         {
             _Handle.HandleRequest(reqState, _ComModel);
         }
     }

通过加了一层,再来看一下调用方的代码:

 ComponentModel comModel = new ComponentModel();
 CORUnit corunit = new CORUnit(comModel);
 corunit.RegisterHandle(new ConcreteHandlerA());
 corunit.RegisterHandle(new ConcreteHandlerB());
 corunit.HandleRequest(RequestState.Check);
 //执行处理
 //comModel的一些处理

是不是感觉调用方,跟实际的处理方之间的关系变得很弱了,这样目的也就达到了。

«上一页12下一页»


相关评论