如何在FluentValidation中基于属性动态设置SetValidator的规则集？

给定模型 #

public class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

public class FooOfType
{
    public string TypeName { get; set; }
    public Foo Foo { get; set; }
}

给定验证器 #

public class FooValidator : AbstractValidator<Foo>
{
    public FooValidator()
    {
        RuleFor(f => f.Id).NotNull();

        RuleSet("Name", () => {
            RuleFor(f => f.Name).NotNull();
        });

        RuleSet("Email", () => {
            RuleFor(f => f.Email).NotNull();
        });
    }
}

public class FooOfTypeValidator : AbstractValidator<FooOfType>
{
    private string _fooType = "Name"; // 默认类型

    public FooOfTypeValidator()
    {
        RuleFor(f => f.TypeName)
            .NotNull();

        RuleFor(f => f.Foo).SetValidator(new FooValidator(), _fooType // 能否动态设置此参数);
    }
}

问题描述 #

运行该验证器时，即使尝试修改_fooType的值，它也始终为"Name"，因为该值是在构造函数中设置的。需要找到一种方式动态设置ruleSets参数，使其能基于TypeName这类其他属性的值来确定。

解决方案 #

可以通过FluentValidation的Custom验证方法手动触发子验证，或者利用SetValidator的lambda重载实现动态RuleSet传递，以下是两种可行方案：

方案一：使用Custom方法手动控制验证流程 #

public class FooOfTypeValidator : AbstractValidator<FooOfType>
{
    public FooOfTypeValidator()
    {
        RuleFor(f => f.TypeName)
            .NotNull();

        RuleFor(f => f.Foo)
            .NotNull()
            .Custom((foo, validationContext) =>
            {
                // 获取当前验证的父对象实例
                var parentInstance = validationContext.InstanceToValidate as FooOfType;
                if (parentInstance == null || string.IsNullOrEmpty(parentInstance.TypeName))
                    return;

                // 初始化子验证器，并根据TypeName指定RuleSet
                var fooValidator = new FooValidator();
                var validationResult = fooValidator.Validate(
                    foo, 
                    options => options.IncludeRuleSets(parentInstance.TypeName)
                );

                // 将子验证的错误信息合并到当前上下文
                foreach (var error in validationResult.Errors)
                {
                    validationContext.AddFailure(
                        $"Foo.{error.PropertyName}", 
                        error.ErrorMessage
                    );
                }
            });
    }
}

方案二：使用SetValidator的lambda重载结合RuleSetValidator #

public class FooOfTypeValidator : AbstractValidator<FooOfType>
{
    public FooOfTypeValidator()
    {
        RuleFor(f => f.TypeName)
            .NotNull();

        RuleFor(f => f.Foo)
            .NotNull()
            .SetValidator(ctx => 
            {
                // 从父上下文获取TypeName属性值
                var typeName = (ctx.ParentContext.InstanceToValidate as FooOfType)?.TypeName;
                // 用RuleSetValidator包装子验证器，动态指定RuleSet
                return new RuleSetValidator(typeName, new FooValidator());
            });
    }
}

方案说明 #

• 方案一灵活性更高，可完全控制验证逻辑和错误信息的格式，适合需要自定义错误输出的场景。
• 方案二代码更紧凑，利用FluentValidation内置的RuleSetValidator实现规则集的动态绑定，符合框架原生写法。

两种方案都能实现根据TypeName动态选择对应的RuleSet进行验证，解决了构造函数中参数固定的问题。

内容的提问来源于stack exchange，提问作者JHJ