FluentValidation为派生类型设置集合验证器

Question

如何在派生类型的集合项上设置验证器？

class BaseClass
{

}

class DerivedClass : BaseClass
{

}

class SomeClass
{
    public IEnumerable<BaseClass> BaseClasses { get; set; }
}

class DerivedClassValidator : AbstractValidator<DerivedClass>
{

}

class SomeClassValidator : AbstractValidator<SomeClass>
{
    public SomeClassValidator()
    {
        RuleFor(x => x.BaseClasses).????.SetCollectionValidator(new DerivedClassValidator);
    }
}

我在想...

有没有一种方法可以将它转换为特定类型，比如

RuleFor(x => x.SomeCollection).CastTo(typeof(SomeDerivedType)).SetCollectionValidator(new SomeDerivedValidator());

- icube

Answer 1

你可以使用条件规则包装来验证包含不同派生类型对象的集合。

假设你有以下类层次结构：

public class BaseClass
{
    public string Name { get; set; }
}

public class DerivedClassOne : BaseClass
{
    public int Count { get; set; }
}

public class DerivedClassTwo : BaseClass
{
    public double Price { get; set; }
}

一个包含BaseClass对象集合的容器类：

public class ContainerClass
{
    public List<BaseClass> Collection { get; set; } 
}

主要思想是创建一个验证器类，负责所有类层次结构的验证：

public class CommonBaseClassValidator : AbstractValidator<BaseClass>
{
    public CommonBaseClassValidator()
    {
        //common rule for all BaseClass types
        RuleFor(x => x.Name)
            .NotEmpty();

        // special rules for base type
        When(model => model.GetType() == typeof (BaseClass), () =>
        {
            RuleFor(x => x.Name)
                .Length(0, 10);
            // add rules here
        });

        //special rules for derived types
        When(model => model.GetType() == typeof(DerivedClassOne), () =>
        {
            RuleFor(model => ((DerivedClassOne) model).Count)
                .ExclusiveBetween(1, 9);
            // add rules here
        });

        When(model => model.GetType() == typeof(DerivedClassTwo), () =>
        {
            RuleFor(model => ((DerivedClassTwo) model).Price)
                .GreaterThan(1000);
            // add rules here
        });
    }
}

并将此类注册为集合项验证器：

public class ContainerValidator : AbstractValidator<ContainerClass>
{
    public ContainerValidator()
    {
        RuleFor(model => model.Collection)
            .SetCollectionValidator(new CommonBaseClassValidator());
    }
}

- David Levin

Answer 2

我创建这个是为了使处理这种情况更简单：

public class DerivedValidatorBase<TBase> : AbstractValidator<TBase>
{
    public void MapDerivedValidator<TType, TValidatorType>()
        where TValidatorType : IEnumerable<IValidationRule>, IValidator<TType>, new()
        where TType: TBase
    {
        When(t => t.GetType() == typeof(TType), () => AddDerivedRules<TValidatorType>());
    }

    public void MapDerivedValidator<TType, TValidatorType>(TValidatorType validator)
        where TValidatorType : IEnumerable<IValidationRule>, IValidator<TType>
        where TType: TBase
    {
        When(t => t.GetType() == typeof(TType), () => AddDerivedRules<TValidatorType>(validator));
    }

    private void AddDerivedRules<T>(T validator)
        where T : IEnumerable<IValidationRule>
    {
        foreach (var rule in validator)
        {
            this.AddRule(rule);
        }
    }

    private void AddDerivedRules<T>()
        where T : IEnumerable<IValidationRule>, new()
    {
        IEnumerable<IValidationRule> validator = new T();
        foreach (var rule in validator)
        {
            this.AddRule(rule);
        }
    }
}

然后我只需创建一个基本的验证器类：

public class CommonBaseClassValidator : DerivedValidatorBase<BaseClass>
{
    public CommonBaseClassValidator()
    {
        MapDerivedValidator<DerivedClass, DerivedClassValidator>();
    }
}

或者在使用依赖注入时：

public class CommonBaseClassValidator : DerivedValidatorBase<BaseClass>
{
    public CommonBaseClassValidator(DerivedClassValidator validator)
    {
        MapDerivedValidator<DerivedClass, DerivedClassValidator>(validator);
    }
}

使用中：

RuleFor(v => v.BaseClasses).SetCollectionValidator(new CommonBaseClassValidator());

这样我就可以重复使用现有的验证器来验证派生类，而且这些验证器可能已经在其他地方使用过了，映射它们也不需要麻烦。

- ProgrammingLlama

Answer 3

我想补充一些帮助他人的内容。我受Evgeny Levin解决方案的启发。与其在When中列出规则清单，我更喜欢将每个验证器分开。请参考"最初的回答"。

public class CommonBaseClassValidator : AbstractValidator<BaseClass>
{
    public CommonBaseClassValidator()
    {
        //All rules for shared properties
        RuleFor(x => x.Name)
            .NotEmpty();

        RuleFor(x => x.Name)
                .Length(0, 10);

        //special rules for derived types
        When(model => model.GetType() == typeof(DerivedClassOne), 
            () => RuleFor(entity => entity as DerivedClassOne)
                    .SetValidator(new DerivedClassOneValidator()));

        When(model => model.GetType() == typeof(DerivedClassTwo), 
            () => RuleFor(entity => entity as DerivedClassTwo)
                .SetValidator(new DerivedClassTwoValidator()));
    }
}

Hope that helps.

- Angelo Chiello

Answer 4

六年后: 请查看this link。
按照说明操作，最后底部会显示：

这种方法也适用于集合，其中集合的每个元素可能是不同的子类。

- Rzassar