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

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

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

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

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

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

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

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

本文转自 virusswb 51CTO博客，原文链接：http://blog.51cto.com/virusswb/1020667，如需转载请自行联系原作者