C#中用Specification模式实现可定制的业务逻辑

这里将要讲述的是怎样用C#中的Specification模式实现可定制的业务逻辑，也就是避免传统where语句的局限性，在一定程度上是有其价值的。

今天有朋友在问了我这么一个问题：怎么实现OrWhere的功能？我猜测，他的意思是要实现这样的功能：

 
 
 
 
    
  
  
  
  
  1. static IEnumerable MorePredicate(IEnumerable source)  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     return source.OrWhere(i => i > 0); // 或所有的正数  
    4.   
  
  
  
  4. }  
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. static void Main(string[] args)  
    7.   
  
  
  
  7. {  
    8.   
  
  
  
  8.     var array = Enumerable.Range(-5, 10).ToArray();  
    9.   
  
  
  
  9.     var odd = array.Where(i => i % 2 != 0);  // 排除所有偶数  
    10.   
  
  
  
  10.     var oddOrPositive = MorePredicate(odd);  
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     foreach (var i in oddOrPositive)  
    13.   
  
  
  
  13.     {  
    14.   
  
  
  
  14.         Console.WriteLine(i);  
    15.   
  
  
  
  15.     }  
    16.   
  
  
  
  16. } 
    17.

以上代码应该输出-5，-3，-1，1，2，3，4。但显然，这段代码是无法编译通过，无法通过补充类库来实现的。因为在Main方法中的Where过后，已经排除了所有的偶数，于是在接下来的代码中是无法从新的序列中再次恢复元素的。

不过这个要求让我想起了Specification模式。Specification模式的作用是构建可以自由组装的业务逻辑元素。Specification类有一个IsSatisifiedBy函数，用于校验某个对象是否满足该Specification所表示的条件。多个Specification对象可以组装起来，并生成新Specification对象，这便可以形成高度可定制的业务逻辑。例如，我们可以使用依赖注入（控制反转）的方式来配置这个业务逻辑，以此保证系统的灵活性。

如果您点开上面那个Wikipedia的链接，就会发现这段描述大约是一个英译中的练习。抄完了“定义”，再来看看同样引自Wikipedia的UML图：

一般来说，Specification模式则意味着实现这样一个接口：

 
 
 
 
    
  
  
  
  
  1. public interface ISpecification   
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     bool IsSatisfiedBy(T candidate);  
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     ISpecification  And(ISpecification  other);   
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.     ISpecification  Or(ISpecification  other);   
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     ISpecification  Not();   
    10.   
  
  
  
  10. } 
    11.

实现了ISpecification的对象则意味着是一个Specification，它可以通过与其他Specification对象的And，Or或对自身的取反来生成新的逻辑。为了方便这些“组合逻辑”的开发，我们还会准备一个抽象的CompositeSpecification类：

 
 
 
 
    
  
  
  
  
  1. public abstract class CompositeSpecification : ISpecification  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     public abstract bool IsSatisfiedBy(T candidate);  
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     public ISpecification And(ISpecification other)  
    6.   
  
  
  
  6.     {  
    7.   
  
  
  
  7.         return new AndSpecification(this, other);  
    8.   
  
  
  
  8.     }  
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     public ISpecification Or(ISpecification other)  
    11.   
  
  
  
  11.     {  
    12.   
  
  
  
  12.         return new OrSpecification(this, other);  
    13.   
  
  
  
  13.     }  
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     public ISpecification Not()  
    16.   
  
  
  
  16.     {  
    17.   
  
  
  
  17.         return new NotSpecification(this);  
    18.   
  
  
  
  18.     }  
    19.   
  
  
  
  19. } 
    20.

CompositeSpecification提供了构建复合Specification的基础逻辑，它提供了And、Or和Not方法的实现，让其他Specification类只需要专注于IsSatisfiedBy方法的实现即可。例如，以下便是三种逻辑组合的具体实现：

 
 
 
 
    
  
  
  
  
  1. public class AndSpecification : CompositeSpecification  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     private ISpecification m_one;  
    4.   
  
  
  
  4.     private ISpecification m_other;  
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.     public AndSpecification(ISpecification x, ISpecification y)  
    7.   
  
  
  
  7.     {  
    8.   
  
  
  
  8.         m_one = x;  
    9.   
  
  
  
  9.         m_other = y;  
    10.   
  
  
  
  10.     }  
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     public override bool IsSatisfiedBy(T candidate)  
    13.   
  
  
  
  13.     {  
    14.   
  
  
  
  14.         return m_one.IsSatisfiedBy(candidate) && m_other.IsSatisfiedBy(candidate);  
    15.   
  
  
  
  15.     }  
    16.   
  
  
  
  16. }  
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18. public class OrSpecification : CompositeSpecification  
    19.   
  
  
  
  19. {  
    20.   
  
  
  
  20.     private ISpecification m_one;  
    21.   
  
  
  
  21.     private ISpecification m_other;  
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.     public OrSpecification(ISpecification x, ISpecification y)  
    24.   
  
  
  
  24.     {  
    25.   
  
  
  
  25.         m_one = x;  
    26.   
  
  
  
  26.         m_other = y;  
    27.   
  
  
  
  27.     }  
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.     public override bool IsSatisfiedBy(T candidate)  
    30.   
  
  
  
  30.     {  
    31.   
  
  
  
  31.         return m_one.IsSatisfiedBy(candidate) || m_other.IsSatisfiedBy(candidate);  
    32.   
  
  
  
  32.     }  
    33.   
  
  
  
  33. }  
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35. public class NotSpecification : CompositeSpecification  
    36.   
  
  
  
  36. {  
    37.   
  
  
  
  37.     private ISpecification m_wrapped;  
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39.     public NotSpecification(ISpecification x)  
    40.   
  
  
  
  40.     {  
    41.   
  
  
  
  41.         m_wrapped = x;  
    42.   
  
  
  
  42.     }  
    43.   
  
  
  
  43.  
    44.   
  
  
  
  44.     public override bool IsSatisfiedBy(T candidate)  
    45.   
  
  
  
  45.     {  
    46.   
  
  
  
  46.         return !m_wrapped.IsSatisfiedBy(candidate);  
    47.   
  
  
  
  47.     }  
    48.   
  
  
  
  48. } 
    49.

于是，我们便可以使用Specification模式来处理刚才那位朋友的问题。例如，首先他需要排除所有的偶数，那么我们不妨实现一个OddSpecification：

 
 
 
 
    
  
  
  
  
  1. public class OddSpecification : CompositeSpecification  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     public override bool IsSatisfiedBy(int candidate)  
    4.   
  
  
  
  4.     {  
    5.   
  
  
  
  5.         return candidate % 2 != 0;  
    6.   
  
  
  
  6.     }  
    7.   
  
  
  
  7. } 
    8.

自然，还有用于获得所有正数的Specification类：

 
 
 
 
    
  
  
  
  
  1. public class PositiveSpecification : CompositeSpecification  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     public override bool IsSatisfiedBy(int candidate)  
    4.   
  
  
  
  4.     {  
    5.   
  
  
  
  5.         return candidate > 0;  
    6.   
  
  
  
  6.     }  
    7.   
  
  
  
  7. } 
    8.

于是在使用时，我们会将其通过Or方法组合起来：

 
 
 
 
    
  
  
  
  
  1. static ISpecification MorePredicate(ISpecification original)  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     return original.Or(new PositiveSpecification());  
    4.   
  
  
  
  4. }  
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. static void Main(string[] args)  
    7.   
  
  
  
  7. {  
    8.   
  
  
  
  8.     var array = Enumerable.Range(-5, 10).ToArray();  
    9.   
  
  
  
  9.     var oddSpec = new OddSpecification();  
    10.   
  
  
  
  10.     var oddAndPositiveSpec = MorePredicate(oddSpec);  
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     foreach (var item in array.Where(i => oddAndPositiveSpec.IsSatisfiedBy(i)))  
    13.   
  
  
  
  13.     {  
    14.   
  
  
  
  14.         Console.WriteLine(item);  
    15.   
  
  
  
  15.     }  
    16.   
  
  
  
  16. } 
    17.

但是，您觉得这个做法怎么样？我觉得过于杀鸡用牛刀，高射炮打蚊子了。Specification模式虽然常用，但是用在这里太重量级了。如果我们为每一个函数都补充一个Specification类，至少会让我感到厌倦。

以上的代码其实转载自Wikipedia词条，不过我修改了一些命名，以及改写成泛型版本。我们有理由推测，Wikipedia上是非常旧的内容，很可能是在C#只是1.0版本的时候编写的代码（或者说它为了“兼容”Java那种语言的实现方式）。那么在实际开发过程中，我们又该如何利用C#如今的强大特性来实现出更容易使用，甚至是更为“轻量级”的Specification模式呢？

此外，刚才又收到那位朋友的消息，他其实是想在使用LINQ to SQL时实现“可扩展的逻辑”。那么，对于他说的情况，我们又该如何应对呢？

新闻名称：C#中用Specification模式实现可定制的业务逻辑
网页链接：http://www.shufengxianlan.com/qtweb/news48/419848.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

自适应网站知识

同城分类信息

谷歌推广　　 　成都企业网站维护　　 　公司宣传册设计　　 　成都网站优化　　 　教育网站设计方案　　 　节能环保网站建设方案　　 　广安网站设计　　 　成都网络推广公司　　 　轻质隔墙板　　 　内江托管服务器　　 　温江做网站　　 　服务器托管　　 　成都网站建设　　 　服务器租用　　 　成都木托盘　　 　香港虚拟主机空间　　 　混凝土搅拌车　　 　重庆电商网站定制　　 　解决方案　　 　成都网站建设