派生类型的FluentValidation SetCollectionValidator

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());

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

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());

这样我就可以为派生类重新使用现有的验证器，我可能会在其他地方使用这些验证器，并轻松映射它们。