没有想到自己头脑发热写了一个简陋版本的所谓“验证框架”能够得到众多网友的推荐。个人觉得这个验证框架有两个主要的特点是：提供CompositeValidator使复杂逻辑判断成为可能；提供多验证规则的支持。《编程篇》中，我主要介绍了如何通过自定义特性的方式进行验证规则的定义，在本篇中我主要来介绍该验证框架的设计原理和实现。

一、核心三人组：Validator、ValidatorAttribute和ValidationError

应该说整个验证框架的核心体系只包含如下三中类型：Validator、ValidatorAttribute和ValidationError

Validator：所有的验证逻辑均实现在相应的“验证器”中，具体的验证器均直接或者间接继承自Validator这个抽象基类；
ValidatorAttribute：上述的验证器通过对应的自定义特性（Attribute）的方式应用到相应的数据实体类的属性上，ValidatorAttribute是这些特性的基类；
ValidationError：在Validator进行数据验证的时候，如果数据实体对象顺利通过验证，则返回Null，否则验证的错误信息封装成一个ValidationError对象返回。

上面的类图反映了上述三个核心类型的属性和操作，以及它们之间的关系。Validator通过Validate方法对传入的数据实体进行验证，验证失败的错误结果以ValidationError对象的形式返回；通过将相应的Validator应用到数据类型的目标属性上的ValidatorAttribute最终需要完成对Validator的创建。

实际上，上述三个类型的定义都比较简单，我们先来看看Validator这个抽象类的定义。如下面的代码所示，Validator具有一个MessageTemplate的属性，表示验证错误信息的模板，该模板具有一些预定义的占位符。这些占位符可以包括与具体Validator无关的一般意义的对象，比如{PropertyName}、{PropertyValue}表示目标属性名和属性值，也包括一些具体Validator专有的占位符，比如编程篇》提到的GreaterThanValidator的{LowerBound}和LessThanValidator的{UpperBound}。虚FormatMessage方法用于对MessageTemplate进行格式化，即通过相应的值来替换对应的占位符。在这里将被验证的值替换掉{PropertyValue}占位符。最终的验证通过抽象方法Validate体现。

 
public abstract class Validator 
{ 
    public string MessageTemplate { get; protected set; } 
    public abstract ValidationError Validate(object objectToValidate); 
    public Validator(string messageTemplate) 
    { 
        this.MessageTemplate = messageTemplate ?? string.Empty; 
    } 
    public virtual void FormatMessage(object objectToValidate) 
    { 
        this.MessageTemplate = this.MessageTemplate.Replace("{PropertyValue}", objectToValidate.ToString()); 
    } 
    protected  ValidationError CreateValidationError(object objectToValidate) 
    { 
        Guard.ArgumentNotNull(objectToValidate, "objectToValidate"); 
        return new ValidationError(this.MessageTemplate, objectToValidate, this); 
    } 
} 
  

我们接着分析ValidatorAttribute的定义。如下面提供的代码片断所示，这是一个继承自Attribute的抽象类。MessageTemplate属性无需多说，RuleName属性表示验证规则的名称。而Tag是为了灵活实现对消息模板格式化的需要，你可以在MessageTemplate中定义{Tag}占位符，然后通过该属性指定替换它的值。ValidatorAttribute同样定义需方法FormatMessage，在这里我们用属性名称替换{PropertyName}占位符。我们的框架最终需要通过ValidatorAttribute创建相应的Validator，这个操作以抽象方法CreateValidator方法提供。

 
[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)] 
public abstract class ValidatorAttribute: Attribute 
{ 
    public string RuleName { get; set; } 
    public string Tag { get; set; } 
    public string MessageTemplate { get; private set; } 
    public abstract Validator CreateValidator(); 
   
    public ValidatorAttribute(string messageTemplate) 
    { 
        Guard.ArgumentNotNullOrEmpty(messageTemplate, "messageTemplate"); 
        this.MessageTemplate = messageTemplate; 
        this.RuleName = string.Empty; 
    } 
    public virtual void FormatMessage(PropertyInfo property) 
    { 
        this.MessageTemplate = this.MessageTemplate.Replace("{PropertyName}", property.Name) 
            .Replace("{Tag}", this.Tag); 
    } 
} 
  

表示验证失败信息的ValidationError，我尽量将其定义的简单一点。它包含Message、Target和Validtor三个属性，分别表示错误消息、验证的目标对象和采用的Validator。

 
public class ValidationError 
{ 
    public string       Message { get; internal set; } 
    public object       Target { get; internal set; } 
    public Validator    Validator { get; internal set; } 
   
    public ValidationError(string message, object target, Validator validator) 
    { 
        Guard.ArgumentNotNull(message, "message"); 
        Guard.ArgumentNotNull(target, "target"); 
        Guard.ArgumentNotNull(validator, "validator"); 
   
        this.Message = message; 
        this.Target = target; 
        this.Validator = validator; 
    } 
} 
  

二、一个特殊但却意义重大的Validator：CompositeValidator

正如开篇所说，这个框架一个重要的可取之处在于能够提供对复杂逻辑运算的支持，而这是通过CompositeValidator这种特殊的Validator来实现的。我们提要提供两种具体的CompositeValidator：AndCompositeValidator和OrCompositeValidator，分别用于进行“逻辑与”和“逻辑或”的逻辑判断。它们具有一个相同的抽象基类——CompositeValidator。下面提供的代码片断表明，CompositeValidator仅仅在原来的基础上增加了一个IEnumerable<Validator>类型只读属性：Validators。我将Validators集合中的每一个Validator成为构成CompositeValidator的验证器元素（ValidatorElement）。

 
public abstract class CompositeValidator:Validator 
{ 
    public CompositeValidator(string messageTemplate, IEnumerable<Validator> validators):base(messageTemplate) 
    { 
        Guard.ArgumentNotNull(validators, "validators"); 
        this.Validators = validators; 
    } 
    public IEnumerable<Validator> Validators { get; private set; } 
} 
  

而AndCompositeValidator和OrCompositeValidator定义也很简单，不用多说你也能够看明白具体采用的验证逻辑。

 
public class AndCompositeValidator: CompositeValidator 
{ 
    public AndCompositeValidator(string messageTemplate,IEnumerable<Validator> validators) 
        : base(messageTemplate,validators) 
    { } 
   
    public override ValidationError Validate(object objectToValidate) 
    { 
        foreach (var validator in this.Validators) 
        { 
            if (null != validator.Validate(objectToValidate)) 
            { 
                return this.CreateValidationError(objectToValidate); 
            } 
        } 
        return null; 
    } 
} 
  

 
public class OrCompositeValidator : CompositeValidator 
{ 
    public OrCompositeValidator(string messageTemplate, IEnumerable<Validator> validators) 
        : base(messageTemplate,validators){ } 
   
    public override ValidationError Validate(object objectToValidate) 
    { 
        foreach (var validator in this.Validators) 
        { 
            var validationError = validator.Validate(objectToValidate); 
            if (null == validationError) 
            { 
                return null; 
            } 
        } 
        return this.CreateValidationError(objectToValidate); 
    } 
} 
  

基于重用的目的，我们会CompositeValidator定义了ValidatorAttribute基类：CompositeValidatorAttribute。我们将所有ValidatorElement的名称用逗号作为分隔符连接成一个字符串参数传入到构造函数中。

 
public abstract class CompositeValidatorAttribute : ValidatorAttribute 
{         
    public IEnumerable<string> ValidatorElements { get; private set; } 
    public CompositeValidatorAttribute(string messageTemplate, string validatorElements):base(messageTemplate) 
    { 
        Guard.ArgumentNotNullOrEmpty(validatorElements, "validatorElements"); 
        this.ValidatorElements = validatorElements.Split(','); 
    } 
    public abstract CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validator); 
    public override Validator CreateValidator() 
    { 
        throw new NotImplementedException(); 
    } 
} 
  

三、验证器元素（ValidatorElement）如何定义？

我们所有的验证规则均通过自定义特性（Attribute）的方式进行定义，说白了就是通过特性的方式将相应的Validator应用到数据类型的目标属性中去。Validator通过ValidatorAttribute可以方便地进行应用，但是构成上述CompositeValidator的验证器元素有如何应用呢？在这里我创建了另一种类型的特性——ValidatorElementAttribute。和ValidatorAttribute不同，ValidatorElementAttribute没有定义MessageTemplate属性，应为最终的验证消息通过CompositeValidator来提供。ValidatorElementAttribute提供了一个Name属性，表示该验证器元素的唯一标识。ValidatorElementAttribute和ValidatorAttribute一样，最终通过CreateValidator创建相应的Validator。

 
[AttributeUsage(AttributeTargets.Property, AllowMultiple =true)] 
public abstract class ValidatorElementAttribute:Attribute 
{ 
    public string Name { get; private set; } 
    public ValidatorElementAttribute(string name ) 
    { 
        Guard.ArgumentNotNullOrEmpty(name, "name"); 
        this.Name = name; 
    } 
    public abstract Validator CreateValidator(); 
} 
  

四、CompositeValidator需要有特殊的ValidatorElementAttribute

对于任何一个具体的Validator，由于它既可以作为独立的验证器进行数据验证工作，也可以作为CompositeValidator的验证器元素协同其他的Validator一起完成复杂逻辑判断。所以一个Validator同时具有一个ValidatorAttribute和ValidatorElementAttribute，即使CompositeValidator本身也不能例外。原因很简单，CompositeValidator本身通过自己的ValidatorElement按照相应的逻辑判断规则进行验证，其自身也可以作为另一个CompositeValidator的ValidatorElement。

但是基于CompositeValidator的ValidatorElementAttribute有点特别，以至于我们不得不为之定义一个单独的基类：CompositeValidatorElementAttribute。由于CompositeValidator具有一个以IEnumerable<Validator>对象体现的验证器元素的列表，在ValidatorElementAttribute的CreateValidator方法中无法获取，所以不得不创建一个额外的CreateCompositeValidator抽象方法，以输入参数的方式提供验证器元素列表。

 
public abstract class CompositeValidatorElementAttribute : ValidatorElementAttribute 
{ 
    public IEnumerable<string> ValidatorElements { get; private set; } 
    public CompositeValidatorElementAttribute(string name, string validatorElements) 
        : base(name) 
    { 
        Guard.ArgumentNotNullOrEmpty(validatorElements, "validatorElements"); 
        this.ValidatorElements = validatorElements.Split(','); 
    } 
    public abstract CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validators); 
    public override Validator CreateValidator() 
    { 
        throw new NotImplementedException(); 
    } 
} 
  

以上我们着重在介绍CompositeValidator的设计，CompositeValidator以及相关的ValidatorElementAttribute和CompositeValidatorElementAttribute之间的关系可以通过下面的类图表示。

五、最终的验证如何进行？

到目前为止，构成验证框架的所有核心的元素都已经介绍完成，现在我们来看看最终的验证是如何进行的。在《编程篇》我们可以看到没，我们最终是调用静态外观类Validation的Validate方法对数据实体对象进行验证的。具体来说我们定义了如下两个Validate重载，其正一个可以指定验证规则名称。

 
public static class Validation 
{     
    public static bool Validate(object value, out IEnumerable<ValidationError> validationErrors) 
    { 
        return Validate(value,string.Empty, out validationErrors); 
    } 
   
    public static bool Validate(object value, string ruleName, out IEnumerable<ValidationError> validationErrors) 
    { 
        //省略 
    } 
} 
  

最终的验证逻辑都实现在带ruleName参数的Validate方法中，下面是该方法的定义。只要的逻辑就是：通过反射获取验证对象类型的共有PropertyInfo，并通过它和验证规则名称得到匹配的Validator的列表，然后用它们对属性的值进行验证。

 
public static bool Validate(object value, string ruleName, out IEnumerable<ValidationError> validationErrors) 
{ 
    validationErrors = new List<ValidationError>(); 
    Guard.ArgumentNotNull(value, "value"); 
    foreach (var property in value.GetType().GetProperties()) 
    { 
        var validators = GetValidators(ruleName, property); 
        if (validators.Count() > 0) 
        { 
            var propertyValue = property.GetValue(value, null); 
            foreach (var validator in validators) 
            { 
                validator.FormatMessage(propertyValue); 
                var error = validator.Validate(propertyValue); 
                if (null != error) 
                { 
                    ((List<ValidationError>)validationErrors).Add(error); 
                } 
            } 
        } 
    } 
    return validationErrors.Count() == 0; 
} 
  

实际上Validate方法中最复杂的逻辑在于如何通过PropertyInfo和验证规则的名称获取匹配的Validator的列表。主要的思路还是通过PropertyInfo进行反射获取应用在上面的ValidatorAttribute，并通过得到ValidatorAttribute创建相应的Validator。不过这其中涉及到对Validator的缓存，以及的CompositeValidator创建时采用的递归，代码相对较多，在这里不作具体介绍了。有兴趣的朋友可以从这里下载源代码进行分析。

六、更多的考虑

和我很多文章一样，这篇文章仅仅是为某个应用场景提供一种大体上的思路，或者提供一种最为简单的解决方案。如果你需要将这些半理论的东西用于实践，你应该根据具体的需求做更多的考虑。本文提供的所谓的“验证框架”我之所以打上引号，是因为其粗陋不堪，实际上就是我花了不到3个小时写成的一个小程序。不过，对于这个小程序背后的解决问题的思路，我觉得还是可取的。有心的朋友不妨从下面的方面对这个“框架”进行扩充：

通过配置+特性的方式是验证规则的变得更加灵活；
Validator不仅仅能够应用于属性，可以考虑字段；
Validator不仅仅能够应用公有成员，或许可以考虑非公有成员；
Validator不仅仅可以应用于属性、字段，也可以应用于整个类型，这就可以对整个对象级别定义验证规则，比如验证StartDate〈EndDate（StartDate和EndDate对应两个属性）；
Validator还可以应用于方法的参数；
考虑和相应AOP框架集成，让验证（主要是参数验证）自动完成；
如果你希望将Validator应用于WCF服务或者契约方法的参数，可以考虑通过WCF扩展让验证工作自动执行；
通过Resource的方式定义验证消息模板，可以获得多语言文化的支持
其他

采用一个自创的"验证框架"实现对数据实体的验证[编程篇]
采用一个自创的"验证框架"实现对数据实体的验证[设计篇]
采用一个自创的"验证框架"实现对数据实体的验证[改进篇]
采用一个自创的"验证框架"实现对数据实体的验证[扩展篇]

作者：蒋金楠
微信公众账号：大内老A
微博： www.weibo.com/artech
如果你想及时得到个人撰写文章以及著作的消息推送，或者想看看个人推荐的技术资料，可以扫描左边二维码（或者长按识别二维码）关注个人公众号（原来公众帐号蒋金楠的自媒体将会停用）。
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

原文链接

采用一个自创的"验证框架"实现对数据实体的验证[设计篇]

一、核心三人组：Validator、ValidatorAttribute和ValidationError

二、一个特殊但却意义重大的Validator：CompositeValidator

三、验证器元素（ValidatorElement）如何定义？

五、最终的验证如何进行？

六、更多的考虑

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

采用一个自创的"验证框架"实现对数据实体的验证[设计篇]

一、核心三人组：Validator、ValidatorAttribute和ValidationError

二、一个特殊但却意义重大的Validator：CompositeValidator

三、验证器元素（ValidatorElement）如何定义？

五、最终的验证如何进行？

六、更多的考虑

热门文章

最新文章

相关电子书