自《编程篇》和《设计篇》发布以来，收到了一些反馈。尤其是园友双鱼座提到.NET 3.5下的System.ComponentModel.DataAnnotations命名空间具有相似的实现，并且通过“表达式”的方式实现了CompositeValidator的服务逻辑判断的功能。为此，我对这个“验证框架”进行了相应的改进，让CompositeValidator具有了解析“验证表达式”的能力。为了让大家对此改进又一个深刻的认识，我们来对比之下对于同一个验证规则，改进前后有何不同。[源代码从这里下载]
一、改进前如何使用CompositeValidator？
改进前的CompositeValidator仅仅提供对两种基本逻辑运算（“析取”和“或取”）的支持，他们分别通过两个具体的CompositeValidator实现，即AndCompositeValidator和OrCompositeValidator。那么对于一些相对复杂的验证规则，应用在属性上的ValidatorAttribute或者ValidatorElementAttribute有可能需要很多，将使我们的代码显得非常臃肿。通过采用《编程篇》中的“找对象”的例子，如果对年龄具有这样的要求：年龄要么在18到25周岁之间，要么在40岁到50周岁之间，对于这段不算太复杂的验证规则，我们需要在Age属性上添加如下7个特性。
代码语言：js复制 1: public class Mate
2: {
3: private const string messageTemplate = "通过属性{PropertyName}表示的{Tag}要么在18到25周岁之间，要么在40到50周岁之间。 当前{Tag}为{PropertyValue}周岁！";
4:
5: [OrCompositeValidator(messageTemplate,"between18And25,between40And50",Tag = "年龄")]
6: [AndCompositeValidatorElement("between18And25", "greaterThan18,lessThan25")]
7: [AndCompositeValidatorElement("between40And50", "greaterThan40,lessThan50")]
8: [GreaterThanValidatorElement("greaterThan18", 18)]
9: [GreaterThanValidatorElement("greaterThan40", 40)]
10: [LessThanValidatorElement("lessThan25", 25)]
11: [LessThanValidatorElement("lessThan50", 50)]
12: public int Age { get; set; }
13:
14: public Mate(int age)
15: {
16: this.Age = age;
17: }
18: }采用《编程篇》中定义的辅助方法Validate，我们通过如下的代码对具有不同Age属性值的Mate对象实施验证。对于不同的年龄——16（不符合要求）、20（符合要求）、28（不符合要求）、45（符合要求）和60（不符合要求），分别具有不同的验证结果。
代码语言：js复制 1: static void Main(string[] args)
2: {
3: var mate = new Mate(16);
4: Validate<Mate>(mate);
5:
6: mate.Age = 20;
7: Validate<Mate>(mate);
8:
9: mate.Age = 28;
10: Validate<Mate>(mate);
11:
12: mate.Age = 45;
13: Validate<Mate>(mate);
14:
15: mate.Age = 60;
16: Validate<Mate>(mate);
17: }输出结果：
1: 验证失败！
2: 通过属性Age表示的年龄要么在18到25周岁之间，要么在40到50周岁之间。 当前年龄为16周岁！
3: 验证成功！
4: 验证失败！
5: 通过属性Age表示的年龄要么在18到25周岁之间，要么在40到50周岁之间。 当前年龄为28周岁！
6: 验证成功！
7: 验证失败！
8: 通过属性Age表示的年龄要么在18到25周岁之间，要么在40到50周岁之间。 当前年龄为60周岁！
二、在新的CompositeValidator中使用表达式来定义验证规则
如果你采用改进后的验证框架，上面的验证规则可以通过表达式的形式直接写在CompositeValidatorAttribute特性中，下面的代码为你展示了相应的采用改进后的CompositeValidator的Mate类型该如果定义。从中我们可以看出，上述的验证规则对应的表达式为：(V: greaterThan18 AND V: lessThan25) OR (V: greaterThan40 AND V: lessThan50)，不但直观而且简洁。在这段表达式中通过“V:{ValidatorElementName}” 表示相应ValidatorElement最终的验证结果（True或者False）。“V: greaterThan18 ”表示应用在Age属性上名称为greaterThan18的GreaterThanValidatorElementAttribute对应的GreaterThanValidator对Age属性值最终的验证结果。目前为止，验证规则对应的表达式支持三种基本的逻辑操作：AND、OR和NOT，这三个操作符结合括号将会使你的验证表达式具有很强的表达能力。如果还不够，你甚至可以定义更多的逻辑操作符。
代码语言：js复制 1: public class Mate
2: {
3: private const string messageTemplate = "通过属性{PropertyName}表示的{Tag}要么在18到25周岁之间, 要么在40到50周岁之间。 当前{Tag}为{PropertyValue}。";
4:
5: [CompositeValidator(messageTemplate, "(V: greaterThan18 AND V: lessThan25) OR (V: greaterThan40 AND V: lessThan50)",Tag ="年龄")]
6: [GreaterThanValidatorElement("greaterThan18", 18)]
7: [LessThanValidatorElement("lessThan25", 25)]
8: [GreaterThanValidatorElement("greaterThan40", 40)]
9: [LessThanValidatorElement("lessThan50", 50)]
10: public int Age { get; set; }
11:
12: public Mate(int age)
13: {
14: this.Age = age;
15: }
16: }三、最新的CompositeValidator作了哪些改变？
在之前的版本中，CompositeValidator是一个抽象类，我们需要定义继承自该类的具体的CompositeValidator来完成相应的逻辑运算，比如AndCompositeValidator和OrCompositeValidator。在新的版本中，CompositeValidator本身就是一个可以用于验证的Validator。我们为它指定一个验证表达式，它自己可以对表达式进行解析，并调用相应的ValidatorElement实施单一验证。最终将这些单一验证结果按照表达式定义的逻辑关系，得到一个最终的结果。最新的CompositeValidator定义如下：
代码语言：js复制 1: public class CompositeValidator:Validator
2: {
3: public string ValidationExpression { get; private set; }
4: public ExpressionParser ExpressionParser { get; private set; }
5: public IEnumerable<Validator> Validators { get; private set; }
6:
7: public CompositeValidator(string messageTemplate, string validationExpression,IEnumerable<Validator> validators):base(messageTemplate)
8: {
9: Guard.ArgumentNotNullOrEmpty(validationExpression, "validationExpression");
10: Guard.ArgumentNotNull(validators, "validators");
11: this.ValidationExpression = validationExpression;
12: this.Validators = validators;
13: this.ExpressionParser = new ExpressionParser(validators);
14: }
15: public override ValidationError Validate(object objectToValidate)
16: {
17: if (this.ExpressionParser.Parse(this.ValidationExpression).Evaluate(objectToValidate))
18: {
19: return null;
20: }
21: else
22: {
23: return this.CreateValidationError(objectToValidate);
24: }
25: }
26: }通过可以看到，CompositeValidator多了两个只读属性：ValidationExpression和ExpressionParser，分别表示验证表达式和表达式解析器（Parser）。那么在Validate方法中，直接调用ExpressionParser的Parse方法会得到一个自定义的BooleanExpression对象，直接调用该对象的Evaluate方法并传入验证对象作为参数，就可以得到最终的验证结果。
CompositeValidatorAttribute随着CompositeValidator的改进也作了相应的变化。只要是提供了一个表示验证表达式的ValidationExpression的属性，该属性在构造函数中指定。和之前的版本一样，CompositeValidatorAttribute不得不采用显式指定ValidatorElment列表的方式（调用CreateCompositeValidator方法来创建CompositeValidator对象）。
代码语言：js复制 1: public class CompositeValidatorAttribute : ValidatorAttribute
2: {
3: public string ValidationExpression { get; private set; }
4: public CompositeValidatorAttribute(string messageTemplate, string validationExpression)
5: : base(messageTemplate)
6: {
7: Guard.ArgumentNotNullOrEmpty(validationExpression, "validationExpression");
8: this.ValidationExpression = validationExpression;
9:
10: }
11: public CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validators)
12: {
13: return new CompositeValidator(this.MessageTemplate, this.ValidationExpression, validators);
14: }
15: public override Validator CreateValidator()
16: {
17: throw new NotImplementedException();
18: }
19: }对于ExpressionParser得实现，我是借鉴了EnterLib安全模块的Authorization表达式的解析方法。由于逻辑稍微有点复杂，有兴趣的朋友可以分析一下EnterLib的源码，也可以直接下载本验证框架的源代码分析表达式解析的逻辑。
四、最终的验证逻辑变得简单
表达式的引入使CompositeValidator和它们ValidatorElement变成是纯粹的两层关系（原来还有一个CompositeValidatorElement的概念），免去了复杂的递归逻辑操作。我将所有的代码写在下面，里面主要涉及到的逻辑就是如果得到某个属性相匹配的Validator。为了避免频繁的反射和对Validator的创建，我参数了缓存机制。不过代码行数还是不少，如果对此真的感兴趣的话还是下载源代码吧。
代码语言：js复制 1: public static class Validation
2: {
3: private static Dictionary<NamedProperty, IEnumerable<Validator>> validators = new Dictionary<NamedProperty, IEnumerable<Validator>>();
4: private static Dictionary<NamedProperty, IEnumerable<Validator>> validatorElements = new Dictionary<NamedProperty, IEnumerable<Validator>>();
5:
6: private static IEnumerable<Validator> GetValidators(string ruleName, PropertyInfo property)
7: {
8: var key = new NamedProperty(ruleName, property);
9: if (validators.ContainsKey(key))
10: {
11: return validators[key];
12: }
13: lock (typeof(Validation))
14: {
15: if (validators.ContainsKey(key))
16: {
17: return validators[key];
18: }
19: validators[key] = DoGetValidators(ruleName,property);
20: return validators[key];
21: }
22: }
23:
24: private static IEnumerable<Validator> GetValidatorElements(string ruleName, PropertyInfo property)
25: {
26: var key = new NamedProperty(ruleName, property);
27: if (validatorElements.ContainsKey(key))
28: {
29: return validatorElements[key];
30: }
31: lock (typeof(Validation))
32: {
33: if (validatorElements.ContainsKey(key))
34: {
35: return validatorElements[key];
36: }
37: validatorElements[key] = DoGetValidatorElements(ruleName, property);
38: return validatorElements[key];
39: }
40: }
41:
42: private static IEnumerable<Validator> DoGetValidatorElements(string ruleName, PropertyInfo property)
43: {
44: foreach (ValidatorElementAttribute attribute in property.GetCustomAttributes(typeof(ValidatorElementAttribute), true))
45: {
46: yield return attribute.CreateValidator();
47: }
48: }
49:
50: private static IEnumerable<Validator> DoGetValidators(string ruleName, PropertyInfo property)
51: {
52: var validatorAttributes = new List<ValidatorAttribute>();
53:
54: foreach (var attribute in property.GetCustomAttributes(typeof(ValidatorAttribute), true))
55: {
56: ValidatorAttribute validatorAttribute = (ValidatorAttribute)attribute;
57: if (validatorAttribute.RuleName == ruleName)
58: {
59: validatorAttribute.FormatMessage(property);
60: validatorAttributes.Add(validatorAttribute);
61: }
62: }
63:
64: foreach (var attribute in validatorAttributes)
65: {
66: if (attribute is CompositeValidatorAttribute)
67: {
68: yield return ((CompositeValidatorAttribute)attribute).CreateCompositeValidator(GetValidatorElements(ruleName, property));
69: }
70: else
71: {
72: yield return attribute.CreateValidator();
73: }
74: }
75: }
76:
77: public static bool Validate(object value, out IEnumerable<ValidationError> validationErrors)
78: {
79: return Validate(value,string.Empty, out validationErrors);
80: }
81:
82: public static bool Validate(object value, string ruleName, out IEnumerable<ValidationError> validationErrors)
83: {
84: validationErrors = new List<ValidationError>();
85: Guard.ArgumentNotNull(value, "value");
86: foreach (var property in value.GetType().GetProperties())
87: {
88: var validators = GetValidators(ruleName, property);
89: if (validators.Count() > 0)
90: {
91: var propertyValue = property.GetValue(value, null);
92: foreach (var validator in validators)
93: {
94: validator.FormatMessage(propertyValue);
95: var error = validator.Validate(propertyValue);
96: if (null != error)
97: {
98: ((List<ValidationError>)validationErrors).Add(error);
99: }
100: }
101: }
102: }
103: return validationErrors.Count() == 0;
104: }
105: }
106:
107: internal class NamedProperty
108: {
109: public string RuleName { get; set; }
110: public PropertyInfo Property { get; set; }
111:
112: public NamedProperty(string name, PropertyInfo property)
113: {
114: this.RuleName = name ?? string.Empty;
115: Guard.ArgumentNotNull(property, "property");
116: this.Property = property;
117: }
118:
119: public override int GetHashCode()
120: {
121: return this.RuleName.GetHashCode() ^ this.Property.GetHashCode();
122: }
123: }采用一个自创的"验证框架"实现对数据实体的验证[编程篇] 采用一个自创的"验证框架"实现对数据实体的验证[设计篇] 采用一个自创的"验证框架"实现对数据实体的验证[改进篇] 采用一个自创的"验证框架"实现对数据实体的验证[扩展篇]
