[23种设计模式汇总]行为型模式_职责链模式.doc

《[23种设计模式汇总]行为型模式_职责链模式.doc》由会员分享，可在线阅读，更多相关《[23种设计模式汇总]行为型模式_职责链模式.doc（13页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、职责链模式意图是对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直道一个对象处理它为止。使用场合1.有多个对象可以处理一个请求，那个对象处理该请求在运行的时候自动确定。2.希望在不明确制定接收者的情况下，向多个对象中的一个提交一个请求。3.可处理一个请求的对象集合应被动态的指定。例如：过滤器：处理或拦截信息，不同的过滤器可以过滤不同的类型的信息，过滤器可以组成职责链模式。时间处理器：不同事件可以有不同的事件处理器，时间处理器组成职责链。然后用户可以不关心事件的类型，交给职责链处理即可。异常处理器：不同的异常处理器对应不同的异常。文法

2、分析器：对给定的进行文法分析，通过扩充职责链扩充文法分析器的功能。分段计算：职责链上的对象在符合条件时进行计算，这样可以去掉语句。结构：定一个处理请求的接口并实现后续链。：处理负责的请求并可访问后继者。如果可以处理该请求，则处理之；否则将该请求转发给后继者。向链上的具体处理对象提交请求。职责链模式构成与执行效率有些情况下，职责链中各对象完成的任务没有包含性，如在文法分析其中各种是平行关系。这时，职责链中对象的顺序对执行结果没有影响。然而由于职责链是串行的德，链中的前一个对象无法完成任务就交给后一个对象完成。因此职责链中对象的顺序组织方式不同，会大大影响程序的执行效率。在组织职责链对象的顺序时，

3、应将较常用的对象放置在链的前端。结果使用职责链降低了请求与响应的耦合性，职责链的顺序可以有用户来决定。采用职责链的不足如果没有适合处理请求的对象，请求将对不到处理。文法分析器四则运算式解析这里我们的目的是将普通中则表达式转化为后则表达式。方案：四则运算式涉及到种，即参与运算的数字、运算符（以及将来肯能扩充的运算符）、左括号(和右括号)。为了方便字符串分割，这里将字符串的格式规定为数值和运算符、运算符与运算符之间都用空格隔开。例如(_2_+_3_)_/_3采用ArrayList模拟堆栈Stack.csusing System;using System.Collections;using Syst

4、em.Text;namespace ChainofResposibility.EX24_3 /*/ / Stact采用ArrayList模拟堆栈 / class AStack private ArrayList myStact; public int Count get return myStact.Count; public AStack() myStact=new ArrayList(); public void Push(Object o) myStact.Add(o); public Object Pop() int idx = myStact.Count - 1; if (idx 0

5、) throw new Exception(堆栈已空); object o = myStactidx; myStact.RemoveAt(idx); return o; public Object Pop2() if (myStact.Count = 0) throw new Exception(堆栈已空); object o = myStact0; myStact.RemoveAt(0); return o; public bool IsEmpty() return(myStact.Count=0); public object TopItem() int idx = myStact.Cou

6、nt - 1; if (idx0) throw new Exception(堆栈已空); object o = myStactidx; return o; 处理四则表达式中token的基础类TreatToken.csusing System;using System.Collections;using System.Text;namespace ChainofResposibility.EX24_3 /*/ / TreatToken处理四则表达式中token的基础类 / abstract class TreatToken /用来处理token的临时堆栈 protected AStack st;

7、 /用来保存结果的堆栈 protected AStack stOutput; /Next构成职责链 protected TreatToken _next; public TreatToken Next get return _next; set _next = value; public TreatToken(AStack st, AStack stout) this.st = st; this.stOutput=stout; public abstract void Treat(string s); 在这个抽象类中定义了职责链的关系、处理过程中需要用到的堆栈和处理接口。本例有两个Tekon需

8、要处理，即数字和运算符，因为分别对应处理这两种类型的子类：NumberToken.csusing System;using System.Collections;using System.Text;using CommonFrameworkWBs.ValidateTool;namespace ChainofResposibility.EX24_3 /*/ / NumberToken处理数字 / class NumberToken:TreatToken public NumberToken(AStack st, AStack stout) : base(st, stout) public ove

9、rride void Treat(string s) ValidateNumber vn = new ValidateNumber(); if (vn.IsNumber(s) this.stOutput.Push(s); else this.Next.Treat(s); 处理数字的部分很简单，只要将数字如栈即可。应为后则表达式通过运算符的顺序控制计算，所以参与运算的数字顺序不变。处理运算符的代码：OperatorToken.csusing System;using System.Collections;using System.Text;namespace ChainofResposibili

10、ty.EX24_3 /*/ / OperatorToken处理操作符+-*/()等 / class OperatorToken:TreatToken private MyOperatoer ope; public OperatorToken(AStack st, AStack stout, MyOperatoer op) : base(st, stout) this.ope = op; public override void Treat(string s) if (s = ope.OP) if (st.IsEmpty() | s = () st.Push(ope); else MyOpera

11、toer o = (MyOperatoer)st.TopItem(); while (o.Level = ope.Level | ope.OP = ) MyOperatoer o1 = (MyOperatoer)st.Pop(); if (o1.OP = () break; this.stOutput.Push(o1); if (st.IsEmpty() break; o=(MyOperatoer)st.TopItem(); if (ope.OP != ) st.Push(ope); else this.Next.Treat(s); 处理未知的运算符的类：OtherToken.csusing

12、System;using System.Collections;using System.Text;namespace ChainofResposibility.EX24_3 class OtherToken:TreatToken public OtherToken() : base(null, null) public override void Treat(string s) if (s != ) throw new Exception(无法识别的操作符+s); 负责将组装职责链并完成计算：Parser.csusing System;using System.Collections.Gen

13、eric;using System.Text;namespace ChainofResposibility.EX24_3 /*/ / Parser采用职责链将四则元算转化为后表达式 / class Parser AStack sttemp = new AStack(); AStack stoutput = new AStack(); TreatToken tk; public Parser() NumberToken nt=new NumberToken(sttemp,stoutput); OperatorToken op1 = new OperatorToken(sttemp,stoutpu

14、t,new MyOperatoer(+,11); OperatorToken op2 = new OperatorToken(sttemp, stoutput, new MyOperatoer(-, 11); OperatorToken op3 = new OperatorToken(sttemp, stoutput, new MyOperatoer(*, 10); OperatorToken op4 = new OperatorToken(sttemp, stoutput, new MyOperatoer(/, 10); OperatorToken op5 = new OperatorTok

15、en(sttemp, stoutput, new MyOperatoer(%, 10); OperatorToken op6 = new OperatorToken(sttemp, stoutput, new MyOperatoer(, 9); OperatorToken op7 = new OperatorToken(sttemp, stoutput, new MyOperatoer(), 8); OtherToken ot = new OtherToken(); nt.Next = op1; op1.Next = op2; op2.Next = op3; op3.Next = op4; o

16、p4.Next = op5; op5.Next = op6; op6.Next = op7; op7.Next=ot; tk = nt; public string Do(string s) string sout = ; string strArr = GetStrList(s); for (int i = 0; i strArr.Length; i+) tk.Treat(strArri); while (!sttemp.IsEmpty() stoutput.Push(sttemp.Pop(); while (!stoutput.IsEmpty() sout = stoutput.Pop()

17、.ToString() + + sout; return sout; public AStack ReturnAStack(string s) string strArr = GetStrList(s); for (int i = 0; i strArr.Length; i+) tk.Treat(strArri); while (!sttemp.IsEmpty() stoutput.Push(sttemp.Pop(); return stoutput; private string GetStrList(string s) string strArr=s.Split( .ToCharArray

18、(); return strArr; MyOperatoer.csusing System;using System.Collections;using System.Text;namespace ChainofResposibility.EX24_3 /*/ / MyOperatoer 操作符和优先级 / class MyOperatoer private string _ope; private int _level; public MyOperatoer(string o,int l) _ope=o; _level = l; public string OP get return _op

19、e; set _ope = value; public int Level get return _level; set _level = value; public override string ToString() return _ope; CompToken.csusing System;using System.Collections;using System.Text;using ChainofResposibility.EX24_3;namespace ChainofResposibility.EX24_4 abstract class CompToken:TreatToken

20、protected string token = ; public CompToken(AStack st, AStack stout) : base(st, stout) public override void Treat(string s) if (s = token) double b = Convert.ToDouble(this.stOutput.Pop().ToString(); double a = Convert.ToDouble(this.stOutput.Pop().ToString(); double c = Com(a, b); this.stOutput.Push(

21、c.ToString(); else this.Next.Treat(s); public abstract double Com(double a, double b); AddToken.csusing System;using System.Collections;using System.Text;using ChainofResposibility.EX24_3;namespace ChainofResposibility.EX24_4 class AddToken:CompToken public AddToken(AStack st,AStack stout) : base(st

22、,stout) token = +; public override double Com(double a, double b) return a + b; SubtractionToken.csusing System;using System.Collections;using System.Text;using ChainofResposibility.EX24_3;namespace ChainofResposibility.EX24_4 class SubtractionToken : CompToken public SubtractionToken(AStack st, ASt

23、ack stout) : base(st,stout) token = -; public override double Com(double a, double b) return a - b; MultipToken.csusing System;using System.Collections;using System.Text;using ChainofResposibility.EX24_3;namespace ChainofResposibility.EX24_4 class MultipToken : CompToken public MultipToken(AStack st

24、, AStack stout) : base(st,stout) token = *; public override double Com(double a, double b) return a * b; DivisionToken.csusing System;using System.Collections;using System.Text;using ChainofResposibility.EX24_3;namespace ChainofResposibility.EX24_4 class DivisionToken:CompToken public DivisionToken(

25、AStack st, AStack stout) : base(st,stout) token = /; public override double Com(double a, double b) return a / b; ModToken.csusing System;using System.Collections;using System.Text;using ChainofResposibility.EX24_3;namespace ChainofResposibility.EX24_4 /*/ / ModToken / class ModToken:CompToken publi

26、c ModToken(AStack st, AStack stout) : base(st,stout) token = %; public override double Com(double a, double b) return a%b; static void Main(string args) /得到后则表达式 string s = ( 2 + 3 ) / 3; Parser p = new Parser(); Console.WriteLine(s); Console.WriteLine(p.Do(s); Parser px = new Parser(); /计算后则表达式 Computer c = new Computer(px.ReturnAStack(s); Console.WriteLine(c.Do(); Console.ReadLine();相关模式职责链模式经常和组合模式一起使用，在这种情况下父 组件可以作为其在职责链上的后继。