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

没有想到自己头脑发热写了一个简陋版本的所谓“验证框架”能够得到众多网友的推荐。个人觉得这个验证框架有两个主要的特点是：提供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的方式定义验证消息模板，可以获得多语言文化的支持
• 其他

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