设计模式-规约模式C#版
更新:HHH   时间:2023-1-7


设计模式-规约模式C#版

规约模式的使用场景就是规则,业务规则的碎片化。

业务规则的组合是不固定的,需要做成很容易组合,也很容易拆散的方式,规约模式是一个选择。

下面的例子是一个书店中,用户租书的场景。

需要判断用户的最大租书数和用户的状态,需要同时满足这两个要求,才可以继续租书。最大租书数和状态这两个规则拆散开来,在需要的时候再进行组合。不需要组合的地方,就单独使用这些规则。

针对一个实体有不同的规则,把这些规则碎片化,随意组合和拆散,这样就构成了规约模式。

 

  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.Linq; 
  4. using System.Text; 
  5.  
  6. namespace DomainModel.Model 
  7.     /// <summary> 
  8.     /// 规约模式 
  9.     /// </summary> 
  10.     /// <typeparam name="T"></typeparam> 
  11.     public interface ISpecification<T> 
  12.     { 
  13.         bool IsSatisfiedBy(T entity); 
  14.         /// <summary> 
  15.         /// 与规约 
  16.         /// </summary> 
  17.         /// <param name="specification"></param> 
  18.         /// <returns></returns> 
  19.         ISpecification<T> And(ISpecification<T> specification); 
  20.         /// <summary> 
  21.         /// 或规约 
  22.         /// </summary> 
  23.         /// <param name="specification"></param> 
  24.         /// <returns></returns> 
  25.         ISpecification<T> Or(ISpecification<T> specification); 
  26.         /// <summary> 
  27.         /// 非规约 
  28.         /// </summary> 
  29.         /// <returns></returns> 
  30.         ISpecification<T> Not(); 
  31.     } 
  32.  
  33.     public class Customer 
  34.     { 
  35.         private ISpecification<Customer> _hasReachedMax; 
  36.         private ISpecification<Customer> _active; 
  37.  
  38.         public Customer(ISpecification<Customer> hasReachedMax, ISpecification<Customer> active) 
  39.         { 
  40.             this._hasReachedMax = hasReachedMax; 
  41.             this._active = active; 
  42.         } 
  43.         public int TotalRentNumber { getset; } 
  44.         public bool Active 
  45.         { 
  46.             get { return true; } 
  47.         } 
  48.  
  49.         public bool CanRent() 
  50.         { 
  51.             var specification = this._hasReachedMax.Not().And(this._active.Not()); 
  52.             return specification.IsSatisfiedBy(this); 
  53.         } 
  54.     } 
  55.  
  56.     public class HasReachedMaxSpecification : CompositeSpecification<Customer> 
  57.     { 
  58.         public override bool IsSatisfiedBy(Customer entity) 
  59.         { 
  60.             return entity.TotalRentNumber >= 6; 
  61.         } 
  62.     } 
  63.     public class CustomerActiveSpecification : CompositeSpecification<Customer> 
  64.     { 
  65.         public override bool IsSatisfiedBy(Customer entity) 
  66.         { 
  67.             return entity.Active; 
  68.         } 
  69.     } 
  70.     /// <summary> 
  71.     /// 组合规约 
  72.     /// </summary> 
  73.     /// <typeparam name="T"></typeparam> 
  74.     public abstract class CompositeSpecification<T> : ISpecification<T> 
  75.     { 
  76.  
  77.         public abstract bool IsSatisfiedBy(T entity); 
  78.  
  79.         public ISpecification<T> And(ISpecification<T> specification) 
  80.         { 
  81.             return new AndSpecification<T>(this, specification); 
  82.         } 
  83.  
  84.         public ISpecification<T> Not() 
  85.         { 
  86.             return new NotSpecification<T>(this); 
  87.         } 
  88.  
  89.         public ISpecification<T> Or(ISpecification<T> specification) 
  90.         { 
  91.             throw new NotImplementedException(); 
  92.         } 
  93.  
  94.  
  95.     } 
  96.  
  97.     public class AndSpecification<T> : CompositeSpecification<T> 
  98.     { 
  99.         private ISpecification<T> _left; 
  100.         private ISpecification<T> _right; 
  101.         public AndSpecification(ISpecification<T> left, ISpecification<T> right) 
  102.         { 
  103.             this._left = left; 
  104.             this._right = right; 
  105.         } 
  106.         public override bool IsSatisfiedBy(T entity) 
  107.         { 
  108.             return this._left.IsSatisfiedBy(entity) && this._right.IsSatisfiedBy(entity); 
  109.         } 
  110.     } 
  111.  
  112.     public class OrSpecification<T> : CompositeSpecification<T> 
  113.     { 
  114.         private ISpecification<T> _left; 
  115.         private ISpecification<T> _right; 
  116.         public OrSpecification(ISpecification<T> left, ISpecification<T> right) 
  117.         { 
  118.             this._left = left; 
  119.             this._right = right; 
  120.         } 
  121.         public override bool IsSatisfiedBy(T entity) 
  122.         { 
  123.             return this._left.IsSatisfiedBy(entity) || this._right.IsSatisfiedBy(entity); 
  124.         } 
  125.     } 
  126.  
  127.     public class NotSpecification<T> : CompositeSpecification<T> 
  128.     { 
  129.         private ISpecification<T> _inner; 
  130.         public NotSpecification(ISpecification<T> inner) 
  131.         { 
  132.             this._inner = inner; 
  133.         } 
  134.         public override bool IsSatisfiedBy(T entity) 
  135.         { 
  136.             return !this._inner.IsSatisfiedBy(entity); 
  137.         } 
  138.     } 

 

 

 

参考文献

1.走向.NET架构设计—第五章—业务层模式,原则,实践(前篇)

返回编程语言教程...