根据属性 type/value 延迟子验证器的选择

Question

在 FluentValidation 中，是否有扩展或其他方式来根据正在验证的属性的 type/value 延迟子验证器的 selection？

我的情况是我有一个要验证的通知 class。这个 class 有一个有效负载属性，它可以是多种有效负载类型之一，例如SmsPayload、EmailPayload 等。这些 Payload subclass 中的每一个都有自己的关联验证器，例如分别为 SmsPayloadValidator 和 EmailPayloadValidator。除上述内容外，核心库中没有对各个通知提供程序的引用。本质上，这意味着我可以根据需要添加提供程序并使用 IoC 连接所有内容。

考虑以下 classes：

public class Notification
{
    public Payload Payload { get; set; }
    public IEnumerable<string> Details { get; set; }
}

public abstract class Payload
{
    public string Message { get; set; }
    public abstract string Type { get; }
}

public class SmsPayload : Payload
{
    public List<string> Numbers { get; set; }
    public string Region { get; set; }
    public string Provider { get; set; }
}

有一个Notification验证器和SmsPayloadValidator如下：

public class NotificationValidator : AbstractValidator<Notification>
{
    public NotificationValidator(IValidator<Payload> payloadValidator)
    {
        RuleFor(notification => notification.Payload).NotNull().WithMessage("Payload cannot be null.");
        RuleFor(notification => notification.Payload).SetValidator(payloadValidator);
    }
}

public class SmsPayloadValidator : AbstractValidator<SmsPayload>
{
    public SmsPayloadValidator()
    {
        RuleFor(payload => payload.Provider)
            .Must(s => !string.IsNullOrEmpty(s))
            .WithMessage("Provider is required.");
        RuleFor(payload => payload.Numbers)
            .Must(list => list != null && list.Any())
            .WithMessage("Sms has no phone numbers specified.");
        RuleFor(payload => payload.Region)
            .Must(s => !string.IsNullOrEmpty(s))
            .WithMessage("Region is required.");
    }
}

正如我提到的，NotificationValidator 所在的程序集不引用单个有效负载验证器 classes 所在的程序集。所有接线都由 Ioc（该项目的简单注入器）处理。

基本上我想做类似下面的事情——首先在 Simple Injector 中注册一个工厂回调：

container.Register<Func<Payload, IValidator<Payload>>>(() => (payload =>
{
    if (payload.GetType() == typeof(SmsPayload))
    {
        return container.GetInstance<ISmsPayloadValidator>();
    }
    else if (payload.GetType() == typeof(EmailPayload))
    {
        return container.GetInstance<IEmailPayloadValidator>();
    }
    else 
    {
        //something else;
    }
}));

这样我就可以 select 合适的验证器如下：

public class NotificationValidator : AbstractValidator<Notification>
{
    public NotificationValidator(Func<Payload, IValidator<Payload>> factory)
    {
        RuleFor(notification => notification.Payload).NotNull().WithMessage("Payload cannot be null.");
        RuleFor(notification => notification.Payload).SetValidator(payload => factory.Invoke(payload));
    }
}

有什么建议吗？还是有更好的方法来做我的建议？如果 none，我将分叉 FluentValidation 存储库并提交 PR。

Answer 1

避开工厂可能会让你的意图更明确一些。虽然最终结果可能与这种方法相同，但您至少可以直接注入 IValidator<Payload> 而不是 Func<Payload, IValidator<Payload>>.

创建一个名为 PolymorphicValidator 的 class。这将允许您以一致的方式重复此模式，并在您需要时提供回退基础验证器。这本质上是推荐的 "composite pattern" 在 Simple Injector 文档中描述 here。

public class PolymorphicValidator<T> : AbstractValidator<T> where T : class
{
    private readonly IValidator<T> _baseValidator;
    private readonly Dictionary<Type, IValidator> _validatorMap = new Dictionary<Type,IValidator>();

    public PolymorphicValidator() { }

    public PolymorphicValidator(IValidator<T> baseValidator)
    {
        _baseValidator = baseValidator;
    }

    public PolymorphicValidator<T> RegisterDerived<TDerived>(IValidator<TDerived> validator) where TDerived : T
    {
        _validatorMap.Add(typeof (TDerived), validator);
        return this;
    }

    public override ValidationResult Validate(ValidationContext<T> context)
    {
        var instance = context.InstanceToValidate;
        var actualType = instance == null ? typeof(T) : instance.GetType();
        IValidator validator;
        if (_validatorMap.TryGetValue(actualType, out validator))
            return validator.Validate(context);
        if (_baseValidator != null)
            return _baseValidator.Validate(context);
        throw new NotSupportedException(string.Format("Attempted to validate unsupported type '{0}'. " +
            "Provide a base class validator if you wish to catch additional types implicitly.", actualType));
    }
}

然后您可以像这样注册您的验证器（可选择提供基础 class 回退和其他子 class 验证器）：

container.RegisterSingle<SmsPayloadValidator>();
//container.RegisterSingle<EmailPayloadValidator>();
container.RegisterSingle<IValidator<Payload>>(() =>
    new PolymorphicValidator<Payload>(/*container.GetInstance<PayloadValidator>()*/)
        .RegisterDerived(container.GetInstance<SmsPayloadValidator>())
      /*.RegisterDerived(container.GetInstance<EmailPayloadValidator>() */);

这将创建一个单例 PolymorphicValidator，其中包含单例子验证器（FluentValidation 团队推荐单例）。您现在可以注入 IValidator<Payload>，如第一个 NotificationValidator 示例所示。

public class NotificationValidator : AbstractValidator<Notification>
{
    public NotificationValidator(IValidator<Payload> payloadValidator)
    {
        RuleFor(notification => notification.Payload)
            .NotNull().WithMessage("Payload cannot be null.")
            .SetValidator(payloadValidator);
    }
}

Answer 2

我同意 Taylor 关于使用 Composite 的回答（因此肯定是 +1），但他的实现并不那么实用。因此，我建议使用稍微不同的实现方式，同时仍然使用复合材料。

如果我没记错的话，你的合成应该如下所示：

public class CompositeValidator<T> : AbstractValidator<T> where T : class
{
    private readonly Container container;

    public CompositeValidator(Container container)
    {
        this.container = container;
    }

    public override ValidationResult Validate(T instance)
    {
        var validators = this.container.GetAllInstances(instance.GetType());

        return new ValidationResult(
            from IValidator validator in validators
            from error in validator.Validate(instance).Errors
            select error);
    }
}

报名方式如下：

// Simple Injector v3.x
container.RegisterCollection(typeof(IValidator<>),
    AppDomain.CurrentDomain.GetAssemblies());

container.Register(typeof(IValidator<>), 
    typeof(CompositeValidator<>), 
    Lifestyle.Singleton);

// Simple Injector v2.x
container.RegisterManyForOpenGeneric(
    typeof(IValidator<>),
    container.RegisterAll,
    AppDomain.CurrentDomain.GetAssemblies());

container.RegisterOpenGeneric(
    typeof(IValidator<>), 
    typeof(CompositeValidator<>), 
    Lifestyle.Singleton);

这里发生的事情如下：

RegisterCollection 调用确保所有验证器都注册为集合。这意味着对于每个 T，其中可以有多个验证器。例如，如果你的系统有一个 PayloadValidator 和一个 SmsPayloadValidator，解析 GetAllInstances<IValidator<SmsPayload>> 将 return 两个验证器，因为 IValidator<in T> 包含 in 关键字（是逆变的）。
Register 注册将为每个请求的 IValidator<T> 注册 CompositeValidator<T> returned。由于简单注入器 differentiates registrations of collections with one-to-one registrations，注入 IValidator<T> 将始终导致注入复合验证器。由于复合验证器只依赖于容器，所以可以注册为单例。
消费者被注入 CompositeValidator<T>（当他们依赖于 IValidator<T> 时），复合验证器将根据确切类型请求一组验证器。因此，如果消费者使用 IValidator<Payload>，复合验证器将确定真实类型（例如 SmsPayload）并为该确切类型请求所有可分配验证器，并将验证转发给这些类型。
如果特定类型没有验证器，复合验证器将自动return一个有效的ValidationResult。

根据属性 type/value 延迟子验证器的选择

Defer the selection of a child validator depending on the property type/value

.net

validation

expression-trees

fluentvalidation

simple-injector

根据 属性 type/value 延迟子验证器的选择

Defer the selection of a child validator depending on the property type/value

.net

validation

expression-trees

fluentvalidation

simple-injector

根据属性 type/value 延迟子验证器的选择