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

自《编程篇》和《设计篇》发布以来，收到了一些反馈。尤其是园友双鱼座提到.NET 3.5下的System.ComponentModel.DataAnnotations命名空间具有相似的实现，并且通过“表达式”的方式实现了CompositeValidator的服务逻辑判断的功能。为此，我对这个“验证框架”进行了相应的改进，让CompositeValidator具有了解析“验证表达式”的能力。为了让大家对此改进又一个深刻的认识，我们来对比之下对于同一个验证规则，改进前后有何不同。[源代码从这里下载]

一、改进前如何使用CompositeValidator？

改进前的CompositeValidator仅仅提供对两种基本逻辑运算（“析取”和“或取”）的支持，他们分别通过两个具体的CompositeValidator实现，即AndCompositeValidator和OrCompositeValidator。那么对于一些相对复杂的验证规则，应用在属性上的ValidatorAttribute或者ValidatorElementAttribute有可能需要很多，将使我们的代码显得非常臃肿。通过采用《编程篇》中的“找对象”的例子，如果对年龄具有这样的要求：年龄要么在18到25周岁之间，要么在40岁到50周岁之间，对于这段不算太复杂的验证规则，我们需要在Age属性上添加如下7个特性。

public class Mate
{
    private const string messageTemplate   = "通过属性{PropertyName}表示的{Tag}要么在18到25周岁之间，要么在40到50周岁之间。 当前{Tag}为{PropertyValue}周岁！";

    [OrCompositeValidator(messageTemplate,"between18And25,between40And50",Tag = "年龄")]
    [AndCompositeValidatorElement("between18And25", "greaterThan18,lessThan25")]
    [AndCompositeValidatorElement("between40And50", "greaterThan40,lessThan50")]
    [GreaterThanValidatorElement("greaterThan18", 18)]
    [GreaterThanValidatorElement("greaterThan40", 40)]
    [LessThanValidatorElement("lessThan25", 25)]
    [LessThanValidatorElement("lessThan50", 50)]
    public int Age { get; set; }

    public Mate(int age)
    {
        this.Age = age;
    }
}

采用《编程篇》中定义的辅助方法Validate，我们通过如下的代码对具有不同Age属性值的Mate对象实施验证。对于不同的年龄——16（不符合要求）、20（符合要求）、28（不符合要求）、45（符合要求）和60（不符合要求），分别具有不同的验证结果。

static void Main(string[] args)
{
    var mate = new Mate(16);
    Validate<Mate>(mate);

    mate.Age = 20;
    Validate<Mate>(mate);

    mate.Age = 28;
    Validate<Mate>(mate);

    mate.Age = 45;
    Validate<Mate>(mate);

    mate.Age = 60;
    Validate<Mate>(mate);
}

输出结果：

验证失败！
        通过属性Age表示的年龄要么在18到25周岁之间，要么在40到50周岁之间。 当前年龄为16周岁！
验证成功！
验证失败！
        通过属性Age表示的年龄要么在18到25周岁之间，要么在40到50周岁之间。 当前年龄为28周岁！
验证成功！
验证失败！
        通过属性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，这三个操作符结合括号将会使你的验证表达式具有很强的表达能力。如果还不够，你甚至可以定义更多的逻辑操作符。

public class Mate
{
    private const string messageTemplate = "通过属性{PropertyName}表示的{Tag}要么在18到25周岁之间, 要么在40到50周岁之间。 当前{Tag}为{PropertyValue}。";

    [CompositeValidator(messageTemplate, "(V: greaterThan18 AND V: lessThan25) OR (V: greaterThan40 AND V: lessThan50)",Tag ="年龄")]
    [GreaterThanValidatorElement("greaterThan18", 18)]
    [LessThanValidatorElement("lessThan25", 25)]
    [GreaterThanValidatorElement("greaterThan40", 40)]
    [LessThanValidatorElement("lessThan50", 50)]
    public int Age { get; set; }

    public Mate(int age)
    {
        this.Age = age;
    }
}

三、最新的CompositeValidator作了哪些改变？

在之前的版本中，CompositeValidator是一个抽象类，我们需要定义继承自该类的具体的CompositeValidator来完成相应的逻辑运算，比如AndCompositeValidator和OrCompositeValidator。在新的版本中，CompositeValidator本身就是一个可以用于验证的Validator。我们为它指定一个验证表达式，它自己可以对表达式进行解析，并调用相应的ValidatorElement实施单一验证。最终将这些单一验证结果按照表达式定义的逻辑关系，得到一个最终的结果。最新的CompositeValidator定义如下：

public  class CompositeValidator:Validator
{
    public string ValidationExpression { get; private set; }
    public ExpressionParser ExpressionParser { get; private set; }
    public IEnumerable<Validator> Validators { get; private set; }

    public CompositeValidator(string messageTemplate, string validationExpression,IEnumerable<Validator> validators):base(messageTemplate)
    {
        Guard.ArgumentNotNullOrEmpty(validationExpression, "validationExpression");
        Guard.ArgumentNotNull(validators, "validators");
        this.ValidationExpression = validationExpression;
        this.Validators = validators;
        this.ExpressionParser = new ExpressionParser(validators);
    }
    public override ValidationError Validate(object objectToValidate)
    {
        if (this.ExpressionParser.Parse(this.ValidationExpression).Evaluate(objectToValidate))
        {
            return null;
        }
        else
        {
            return this.CreateValidationError(objectToValidate);
        }
    }
}

通过可以看到，CompositeValidator多了两个只读属性：ValidationExpression和ExpressionParser，分别表示验证表达式和表达式解析器（Parser）。那么在Validate方法中，直接调用ExpressionParser的Parse方法会得到一个自定义的BooleanExpression对象，直接调用该对象的Evaluate方法并传入验证对象作为参数，就可以得到最终的验证结果。

CompositeValidatorAttribute随着CompositeValidator的改进也作了相应的变化。只要是提供了一个表示验证表达式的ValidationExpression的属性，该属性在构造函数中指定。和之前的版本一样，CompositeValidatorAttribute不得不采用显式指定ValidatorElment列表的方式（调用CreateCompositeValidator方法来创建CompositeValidator对象）。

public class CompositeValidatorAttribute : ValidatorAttribute
{
    public string ValidationExpression { get; private set; }
    public CompositeValidatorAttribute(string messageTemplate, string validationExpression)
        : base(messageTemplate)
    {
        Guard.ArgumentNotNullOrEmpty(validationExpression, "validationExpression");
        this.ValidationExpression = validationExpression;

    }
    public CompositeValidator CreateCompositeValidator(IEnumerable<Validator> validators)
    {
        return new CompositeValidator(this.MessageTemplate, this.ValidationExpression, validators);
    }
    public override Validator CreateValidator()
    {
        throw new NotImplementedException();
    }
}

对于ExpressionParser得实现，我是借鉴了EnterLib安全模块的Authorization表达式的解析方法。由于逻辑稍微有点复杂，有兴趣的朋友可以分析一下EnterLib的源码，也可以直接下载本验证框架的源代码分析表达式解析的逻辑。

四、最终的验证逻辑变得简单

表达式的引入使CompositeValidator和它们ValidatorElement变成是纯粹的两层关系（原来还有一个CompositeValidatorElement的概念），免去了复杂的递归逻辑操作。我将所有的代码写在下面，里面主要涉及到的逻辑就是如果得到某个属性相匹配的Validator。为了避免频繁的反射和对Validator的创建，我参数了缓存机制。不过代码行数还是不少，如果对此真的感兴趣的话还是下载源代码吧。

public static class Validation
{
    private static Dictionary<NamedProperty, IEnumerable<Validator>> validators = new Dictionary<NamedProperty, IEnumerable<Validator>>();
    private static Dictionary<NamedProperty, IEnumerable<Validator>> validatorElements = new Dictionary<NamedProperty, IEnumerable<Validator>>();

    private static IEnumerable<Validator> GetValidators(string ruleName, PropertyInfo property)
    {
        var key = new NamedProperty(ruleName, property);
        if (validators.ContainsKey(key))
        {
            return validators[key];
        }
        lock (typeof(Validation))
        {
            if (validators.ContainsKey(key))
            {
                return validators[key];
            }
            validators[key] = DoGetValidators(ruleName,property);
            return validators[key];
        }
    }

    private static IEnumerable<Validator>  GetValidatorElements(string ruleName, PropertyInfo property)
    {
         var key = new NamedProperty(ruleName, property);
         if (validatorElements.ContainsKey(key))
        {
            return validatorElements[key];
        }
        lock (typeof(Validation))
        {
            if (validatorElements.ContainsKey(key))
            {
                return validatorElements[key];
            }
            validatorElements[key] = DoGetValidatorElements(ruleName, property);
            return validatorElements[key];
        }
    }

    private static IEnumerable<Validator> DoGetValidatorElements(string ruleName, PropertyInfo property)
    {
        foreach (ValidatorElementAttribute attribute in property.GetCustomAttributes(typeof(ValidatorElementAttribute), true))
        {
            yield return attribute.CreateValidator();
        }
    }

    private static IEnumerable<Validator> DoGetValidators(string ruleName, PropertyInfo property)
    {
        var validatorAttributes = new List<ValidatorAttribute>();

        foreach (var attribute in property.GetCustomAttributes(typeof(ValidatorAttribute), true))
        {
            ValidatorAttribute validatorAttribute = (ValidatorAttribute)attribute;
            if (validatorAttribute.RuleName == ruleName)
            {
                validatorAttribute.FormatMessage(property);
                validatorAttributes.Add(validatorAttribute);
            }
        }

        foreach (var attribute in validatorAttributes)
        {
            if (attribute is CompositeValidatorAttribute)
            {
                yield return ((CompositeValidatorAttribute)attribute).CreateCompositeValidator(GetValidatorElements(ruleName, property));
            }
            else
            {
                yield return attribute.CreateValidator();
            }
        }
    }

    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)
    {
        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;
    }
}

internal class NamedProperty
{
    public string RuleName { get; set; }
    public PropertyInfo Property { get; set; }

    public NamedProperty(string name, PropertyInfo property)
    {
        this.RuleName = name ?? string.Empty;
        Guard.ArgumentNotNull(property, "property");
        this.Property = property;
    }

    public override int GetHashCode()
    {
        return this.RuleName.GetHashCode() ^ this.Property.GetHashCode();
    }
}

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