关于生活中的设计模式(二)_.NET_编程开发_程序员俱乐部

中国优秀的程序员网站程序员频道CXYCLUB技术地图
热搜:
更多>>
 
您所在的位置: 程序员俱乐部 > 编程开发 > .NET > 关于生活中的设计模式(二)

关于生活中的设计模式(二)

 2013/11/5 11:36:42  hankskfc  博客园  我要评论(0)
  • 摘要:上篇文章中讨论了以“每个过程”为观察点来处理订单流程。我们定义了一个接口IAction1:publicinterfaceIAction2:{3:voidDoA();4:voidDoB();5:voidDoC();6:....7:}还定义了每个过程“拍下商品”、“付钱到支付宝”…1:publicclass拍下商品:IAction2:{3:voidDoA();4:voidDoB();5:voidDoC();6:
  • 标签:生活 模式 设计 设计模式

上篇文章中讨论了以“每个过程”为观察点来处理订单流程。我们定义了一个接口IAction

class="alt">   1:  public interface IAction
   2:  {
   3:        void DoA();
   4:        void DoB();
   5:        void DoC();
   6:        ....
   7:  }

还定义了每个过程“拍下商品”、“付钱到支付宝”…

   1:  public class 拍下商品:IAction
   2:  {
   3:      void DoA();
   4:      void DoB();
   5:      void DoC();
   6:  }
   7:   
   8:  public class 付款到支付宝:IAction
   9:  {
  10:      void DoA();
  11:      void DoB();
  12:      void DoC();
  13:  }

以及还有一个负责将每个“过程”进行串联的管理类ActionManager

   1:  public class ActionManager
   2:  {
   3:      private IAction _action =null;
   4:      
   5:      public ActionManager(IAction action)
   6:      {
   7:           _action =action;
   8:      }
   9:      
  10:      public void DoSomething()
  11:      {
  12:          _action.DoA();
  13:          _action.DoB();
  14:          _action.DoC();
  15:          ...
  16:      }
  17:  }

最后展示了调用方式:

   1:  var actionMgr = new ActionManager(拍下商品);
   2:  actionMgr.DoSomething();

 

由于实际项目中呢?我们对于IAction每个“动作”(即DoA、DoB、DoC),都会做一些其他的与业务不怎么相关(如日志)或者说在不影响原先的业务逻辑前提下,我要增加一些业务逻辑(比如业务要求在4点之后客户不能确认收货)

 

一开始我们的想法都是比较简单:直接在“确认收货”该过程里面修改逻辑代码!!以及在“每个过程”都添加日志的模块。然后将代码编译成dll文件,做个发布包就OK了。

 

这样的做法有点违反设计模式的“开闭原则”:“说软件实体(类,模块,函数等)应该可以扩展,但是不可以修改”。

 

那么有没有比较优美的做法来改变“直接修改类”的问题呢?

 

优化版做法

在23种设计模式中就有一个符合解决上述问题的解决方案——“装饰者模式”。我的理解就是一个“包装类”,生活中有很多这种例子比如中秋节买的月饼,里面的东西都是差不多的可是在经过盒子的“包装”后让人顿时感觉就“高端 大气 上档次”了。

 

装饰者模式:自己内部拥有一个业务接口(即IAction),而且自己也实现这个业务接口(IAction)。

 

代码如下:

   1:  public void ProcedureWrapper:IAction
   2:  {
   3:      private IAction _innerAction=null;
   4:      
   5:      public ProcedureWrapper(IAction action)
   6:      {
   7:          _innerAction=action;
   8:      }
   9:      
  10:      public void DoA()
  11:      {
  12:        //做一些其他的事情;比如4点之后不执行改动作,直接return;
  13:          
  14:        try
  15:        {
  16:          _innerAction.DoA();
  17:        }catch
  18:        {
  19:          //记录些日志
  20:        }
  21:        
  22:        //改过程完成之后;做一些事情。
  23:      }
  24:      
  25:      public void DoB()
  26:      {
  27:        //做一些其他的事情;比如4点之后不执行改动作,直接return;
  28:          
  29:        try
  30:        {
  31:          _innerAction.DoB();
  32:        }catch
  33:        {
  34:          //记录些日志
  35:        }
  36:        
  37:        //改过程完成之后;做一些事情。
  38:      }
  39:      
  40:      public void DoC()
  41:      {
  42:        //做一些其他的事情;比如4点之后不执行改动作,直接return;
  43:          
  44:        try
  45:        {
  46:          _innerAction.DoC();
  47:        }catch
  48:        {
  49:          //记录些日志
  50:        }
  51:        
  52:        //改过程完成之后;做一些事情。
  53:      }
  54:  }

然后我们修改下ActionManager

   1:  public class ActionManager
   2:  {
   3:      private IAction _action = null;
   4:      
   5:      public ActionManager(IAction action)
   6:      {
   7:          if(action!=null)
   8:          {
   9:              _action=ProcedureWrapper(action);
  10:          }
  11:      }
  12:      
  13:      public void DoSomething()
  14:      {
  15:          if(action!=null)
  16:          {
  17:              _action.DoA();
  18:              _action.DoB();
  19:              _action.DoC();
  20:          }
  21:      }
  22:  }

 

这样的做法虽然满足了上述的要求,但是有个弊端就是每个方法几乎都被定死了即“DoC前”—>“DoC中”—>“DoC后”。在“DoC前和后”都已经规定死了要做什么,要是有些“过程”我们比较特殊(即我不要记日志,或者记日志的方式不一样了)。

 

面对这个问题我能想到的有两种做法:一个用接口IMethodBefore,IMethodAfter;另一种做法就是定义两个事件:OnActionBefore、OnActionAfter

事件的做法大家应该都会做的,也是比较用到的毕竟.Net就是以事件为驱动的。这里我就讲下接口的做法

 

接口定义如下:

   1:  public interface IMethodBefore
   2:  {
   3:      void DoBefore();
   4:  }
   5:   
   6:  public interface IMethodAfter
   7:  {
   8:      void DoAfter();
   9:  }

 

然后呢我定义一个默认的做法类DefaultMethodAction

   1:  public class DefaultMethodAction:IMethodBefore,IMethodAfter
   2:  {
   3:      public DoBefore()
   4:      {
   5:          //做一些通用的事情;如上述的“4点之后不执行该动作”
   6:      }
   7:      
   8:      public DoAfter()
   9:      {
  10:          //做一些通用的事情;如上述的“4点之后不执行该动作”
  11:      }
  12:  }

DefaultMethodAction用于如果没有其他的业务要求我们就做默认的的动作。

 

自定义的IMethodBefore,IMethodAfter该如何实现呢?这种实现有很多种方式,这里提供一种我的方式—反射、特性。

 

特性定义如下:

   1:  public class BeforeAttribute : Attribute
   2:  {
   3:      public IMethodBefore MethodBefore { get; private set; }
   4:      public BeforeAttribute(IMethodBefore before)
   5:      {
   6:          MethodBefore = before;
   7:      }
   8:  }
   9:   
  10:  public class AfterAttribute : Attribute
  11:  {
  12:      public IMethodAfter MethodAfter { get; private set; }
  13:      public BeforeAttribute(IMethodAfter before)
  14:      {
  15:          MethodAfter = before;
  16:      }
  17:  }

 

 

修改下ProcedureWrapper类代码如下:

   1:  public class ProcedureWrapper : IAction
   2:  {
   3:      private IMethodBefore _defaultBefore = null;
   4:      private IMethodAfter _defaultAfter = null;
   5:      private IAction _action = null;
   6:      /// <summary>
   7:      /// key:方法名称 
   8:      /// </summary>
   9:      private Dictionary<string, IMethodBefore> methodBefore = new Dictionary<string, IMethodBefore>();
  10:   
  11:      /// <summary>
  12:      ///  key:方法名称 
  13:      /// </summary>
  14:      private Dictionary<string, IMethodAfter> methodAfter = new Dictionary<string, IMethodAfter>();
  15:      public ProcedureWrapper(IAction action)
  16:      {
  17:          _defaultBefore = new DefaultMethodAction();
  18:          _defaultAfter = new DefaultMethodAction();
  19:          _action = action;
  20:   
  21:          var methods = _action.GetType().GetMethods();
  22:          foreach (var methodInfo in methods)
  23:          {
  24:              var methodName = methodInfo.Name.ToLower();
  25:              var attrBefore =methodInfo.GetCustomAttributes(typeof(BeforeAttribute),true);
  26:              if (attrBefore.Any())
  27:              {
  28:                  var before = attrBefore[0] as BeforeAttribute;
  29:                  if (before != null) methodBefore.Add(methodName,before.MethodBefore);
  30:              }
  31:   
  32:              var attrAfter =methodInfo.GetCustomAttributes(typeof(AfterAttribute),true);
  33:              if (attrAfter.Any())
  34:              {
  35:                    var after = attrBefore[0] as AfterAttribute;
  36:                  if (after != null) methodAfter.Add(methodName,after.MethodAfter);
  37:              }
  38:          }
  39:      }
  40:      public void DoA()
  41:      {
  42:          IMethodBefore before = _defaultBefore;
  43:          IMethodAfter after = _defaultAfter;
  44:          const string key = "doa";
  45:          if (methodBefore.ContainsKey(key))
  46:          {
  47:              before = methodBefore[key];
  48:          }
  49:   
  50:          before.DoBefore();
  51:   
  52:          try
  53:          {
  54:              _action.DoA();
  55:          }
  56:          catch (Exception)
  57:          {
  58:              
  59:              throw;
  60:          }
  61:   
  62:           if (methodAfter.ContainsKey(key))
  63:          {
  64:              after = methodAfter[key];
  65:          }
  66:          after.DoAfter();
  67:      }
  68:   
  69:      public void DoB()
  70:      {
  71:           IMethodBefore before = _defaultBefore;
  72:          IMethodAfter after = _defaultAfter;
  73:          const string key = "dob";
  74:          if (methodBefore.ContainsKey(key))
  75:          {
  76:              before = methodBefore[key];
  77:          }
  78:   
  79:          before.DoBefore();
  80:   
  81:           try
  82:          {
  83:              _action.DoB();
  84:          }
  85:          catch (Exception)
  86:          {
  87:              
  88:              throw;
  89:          }
  90:   
  91:           if (methodAfter.ContainsKey(key))
  92:          {
  93:              after = methodAfter[key];
  94:          }
  95:          after.DoAfter();
  96:      }
  97:   
  98:      public void DoC()
  99:      {
 100:           IMethodBefore before = _defaultBefore;
 101:          IMethodAfter after = _defaultAfter;
 102:          const string key = "doc";
 103:          if (methodBefore.ContainsKey(key))
 104:          {
 105:              before = methodBefore[key];
 106:          }
 107:   
 108:          before.DoBefore();
 109:   
 110:           try
 111:          {
 112:              _action.DoC();
 113:          }
 114:          catch (Exception)
 115:          {
 116:              
 117:              throw;
 118:          }
 119:   
 120:           if (methodAfter.ContainsKey(key))
 121:          {
 122:              after = methodAfter[key];
 123:          }
 124:          after.DoAfter();
 125:      }
 126:  }

 

然后就是我们的每个过程“用法”

 

   1:  public class 拍下商品:IAction
   2:  {
   3:      //在这里你可以打上BeforeAttribute或者AfterAttribute,也可以不打上面的两个标签,让其走默认的做法
   4:      public void DoA()
   5:      {
   6:      
   7:      }
   8:      
   9:      public void DoB()
  10:      {
  11:      
  12:      }
  13:      
  14:      public void DoC()
  15:      {
  16:      
  17:      }
  18:  }

 

我们最终的调用方式还是和原来一样,代码如下:

   1:  var actionMgr = new ActionManager(拍下商品);
   2:  actionMgr.DoSomething();
发表评论
用户名: 匿名