使用表达式定义验证规则

Question

我想创建一个通用验证 class，所以我可以这样做：

Validation v = new Validation();
v.AddRequired(x => this.Name);
v.AddRange(x => x.this.Age, 5, 65);

我不确定如何编写方法定义并进行评估？

其中 AddRequired 将采用 string，而 AddRange 将采用数字类型（int，主要是 double，decimal, 等等)

Answer 1

应该有一些库可用于此任务。但是，您可以通过自己编写来获得一些使用 lambda 的经验。我已经为 AddRange 做了一个实施草案，希望你能从这里走得更远。

    public class Validation<T> {
        private List<RangeValidation> _rangeValidations = new List<RangeValidation>();

        public void AddRange(Func<T, int> func, int min, int max) {
            _rangeValidations.Add(new RangeValidation() {
                func = func,
                min = min,
                max = max
            });
        }

        public bool Validate(T obj) {
            foreach (var rangeValidation in _rangeValidations) {
                int value = rangeValidation.func(obj);
                if (value < rangeValidation.min || value > rangeValidation.max)
                    return false;
            }
            return true;
        }

        private class RangeValidation {
            public Func<T, int> func;
            public int min, max;
        }
    }

Answer 2

使 Validation 成为 x 类型的泛型，根据需要定义采用 Func<x,object> 或其他类型的方法，存储这些函数，并从 [=14= 中调用它们] 方法：

class Validation<T> {
    private IList<Tuple<Func<T,IComparable>,IComparable,IComparable>> rangeChecks = new List<Tuple<Func<T,IComparable>,IComparable,IComparable>>();
    private IList<Func<T,object>> nullChecks = new List<Func<T,object>>;
    public AddRequired(Func<T,object> f) {
        nullChecks.Add(f);
    }
    public AddRange(Func<T,IComparable> f, IComparable low, IComparable high) {
        rangeChecks.Add(Tuple.Create(f, low, high));
    }
    public bool Validate(T x) {
        foreach(var t in rangeChecks) {
            var f = t.Item1;
            var low = t.Item2;
            var high = t.Item3;
            var val = f(x);
            if (v.CompareTo(low) < 0 || v.CompareTo(high) > 0) {
                return false;
            }
        }
        foreach (var t in nullChecks) {
            if (t(x) == null) {
                return false;
            }
        }
        return true;
    }
}

此实现非常简陋 - 它需要在许多地方进行空值检查才能发挥作用。此外，它不是很有效，因为 IComparable 和 object 可以包装值类型。但是，传递和存储 Func<T,...> 对象的方式应该让您了解如何实现其余部分。

Answer 3

一种方法是：

class ObjectToBeValidated {
   public string Name { get; set; }
   public int Age { get; set; }
}

class Validation {
    private List<Expression<Func<ObjectToBeValidated, bool>>> requiredExpressions;
    private List<Expression<Func<ObjectToBeValidated, bool>>> rangeExpressions;

    public void AddRequired(Expression<Func<ObjectToBeValidated, string>> expression)
    {
        Expression<Func<ObjectToBeValidated, bool>> checkRequired = (p => !string.IsNullOrEmpty(expression.Compile().Invoke(p)));
        requiredExpressions.Add(checkRequired);
    }

    public void AddRange(Expression<Func<ObjectToBeValidated, int>> expression, int min, int max)
    {
        Func<ObjectToBeValidated, int> compiledFunc = expression.Compile();
        Expression<Func<ObjectToBeValidated, bool>> checkRange = (p => compiledFunc.Invoke(p) >= min && compiledFunc.Invoke(p) < max);
        rangeExpressions.Add(checkRange);
    }
}

这只会将您的条件存储在 List<T> 中。然后，您必须向 Validation class 添加一个方法来计算表达式：

public bool IsValid(ObjectToBeValidated testObject)
    {
        return requiredExpressions.All(p => p.Compile().Invoke(testObject))
            && rangeExpressions.All(p => p.Compile().Invoke(testObject));
    }

然后像这样使用：

validator.AddRequired(p => p.Name);
validator.AddRange(p => p.Age, 6, 15);

var myObject = new ObjectToBeValidated();
var result = validator.IsValid(myObject);

使用表达式定义验证规则

Using expressions to define validation rules

c#

lambda

expression