如何使用 FluentValidation 在 IValidateOptions 中編寫流暢的驗證規則？

Question

賞金將在 4 天后到期。 此問題的答案有資格獲得+100聲望賞金。 Question3r正在尋找一個規范的答案。

對於 my.Net 5 workerservice 應用程序，我想通過實現IValidateOptions接口來驗證選項，但不想編寫自己的錯誤消息。 這就是我想使用 package FluentValidation.AspNetCore的原因。

鑒於 model

namespace App.Models
{
    public class MyOptions
    {
        public string Text { get; set; }
    }
}

我添加了驗證規則

namespace App.ModelValidators
{
    public class MyOptionsValidator : AbstractValidator<MyOptions>
    {
        public MyOptionsValidator()
        {
            RuleFor(model => model.Text).NotEmpty();
        }
    }
}

接下來我在驗證中使用這個驗證器

namespace App.OptionsValidators
{
    public class MyOptionsValidator : IValidateOptions<MyOptions>
    {
        private readonly IValidator<MyOptions> _validator;
        
        public MyOptionsValidator(IValidator<MyOptions> validator)
        {
            _validator = validator;
        }
        
        public ValidateOptionsResult Validate(string name, MyOptions options)
        {
            var validationResult = _validator.Validate(options);

            if (validationResult.IsValid)
            {
                return ValidateOptionsResult.Success;
            }
            
            return ValidateOptionsResult.Fail(validationResult.Errors.Select(validationFailure => validationFailure.ErrorMessage));
        }
    }
}

最后我設置了 DI 容器

services.AddTransient<IValidator<MyOptions>, ModelValidators.MyOptionsValidator>();
services.AddSingleton<IValidateOptions<MyOptions>, OptionsValidators.MyOptionsValidator>();
services.Configure<MyOptions>(configuration.GetSection("My"));

我想知道這是否可以簡化？

也許我可以只實現IValidateOptions接口，避免AbstractValidator並在.Validate()方法中編寫流暢的規則？

我想要實現的示例代碼

namespace App.OptionsValidators
{
    public class MyOptionsValidator : IValidateOptions<MyOptions>
    {
        public ValidateOptionsResult Validate(string name, MyOptions options)
        {
            var validationResult = options.Text.Should.Not.Be.Empty();

            if (validationResult.IsValid)
            {
                return ValidateOptionsResult.Success;
            }
            
            return ValidateOptionsResult.Fail(validationResult.ErrorMessage);
        }
    }
}

所以我不再需要AbstractValidator<MyOptions>了。

---

我不確定的第一種方法

我沒有使用 FluentValidation，而是使用 DataAnnotations。

• 我將[Required]屬性添加到Text屬性
• 我完全刪除了 class MyOptionsValidator: AbstractValidator<MyOptions>
• 我只在 DI 設置中注冊這個

.

services.AddSingleton<IValidateOptions<MyOptions>, OptionsValidators.MyOptionsValidator>();
services.Configure<MyOptions>(configuration.GetSection("My"));

在MyOptionsValidator ，我像這樣驗證選項

    public ValidateOptionsResult Validate(string name, MyOptions options)
    {
        var validationResults = new List<ValidationResult>();
        
        if (!Validator.TryValidateObject(options, new ValidationContext(options), validationResults, true))
        {
            return ValidateOptionsResult.Fail(validationResults.Select(validationResult => validationResult.ErrorMessage));
        }

        return ValidateOptionsResult.Success;
    }

但也許還有更好的方法:)

Answer 1

我在這篇文章https://dejanstojanovic.net/aspnet/2020/april/validate-configurations-with-fluentvalidation-in-aspnet-core/中找到了以下代碼

public void ConfigureServices(IServiceCollection services)  
{  
    services.Configure<EndpointsConfiguration>(Configuration.GetSection(nameof(EndpointsConfiguration)));  
    services.AddSingleton<AbstractValidator<EndpointsConfiguration>, EndpointsConfigurationValidator>();  
  
    services.AddSingleton<EndpointsConfiguration>(container =>  
    {  
        var config = container.GetService<IOptions<EndpointsConfiguration>>().Value;  
        var validator = container.GetService<AbstractValidator<EndpointsConfiguration>>();  
        validator.Validate(config);  
        return config;  
    });  
  
    services.AddControllers();  
}  

這樣，您可以在AbstractValidator的實現中進行所有驗證，並且它會比您當前的實現更簡單。 我猜使用這個你不需要實現IOptionsValidator 。 這篇文章有一個很好的解釋，所以請參考以獲得更多的見解。

Answer 2

我可以簡化使用System.ComponentModel.DataAnnotations

 public class MyOptions
 {
      [Required]
      public string Text { get; set; }
 }

然后您可以通過管道自定義您的 BadRequest

 services.AddControllers()
         .ConfigureApiBehaviorOptions(opts =>
         {
               opts.InvalidModelStateResponseFactory = context =>
               {
                   var problemDetails = new ViolationProblemDetails()
                   {
                         Instance = context.HttpContext.Request.Path,
                         Status = StatusCodes.Status400BadRequest,
                         Detail = "Please refer to the errors property for additional details."
                    };

                    problemDetails.Violations = new List<Violation>();

                    foreach (var modelState in context.ModelState)
                    {
                        problemDetails.Violations.Add(new Violation()
                        {
                            Field = modelState.Key,
                            Message = string.Join(",",modelState.Value.Errors.Select(a => a.ErrorMessage))
                         });
                        }

                        return new BadRequestObjectResult(problemDetails);
                    };
                })

更多信息https://docs.microsoft.com/en-us/aspnet/core/mvc/models/validation?view=aspnetcore-5.0

Answer 3

我非常喜歡在整個堆棧中使用相同的方法進行驗證，在我的例子中，這是通過 FluentValidation。 以下是我的方法。

為您的選項/設置驗證器創建一個新的基礎驗證器：

public abstract class AbstractOptionsValidator<T> : AbstractValidator<T>, IValidateOptions<T>
    where T : class
{
    public virtual ValidateOptionsResult Validate(string name, T options)
    {
        var validateResult = this.Validate(options);
        return validateResult.IsValid ? ValidateOptionsResult.Success : ValidateOptionsResult.Fail(validateResult.Errors.Select(x => x.ErrorMessage));
    }
}

這擴展了 FluentValidation AbstractValidator<T>以支持IValidateOptions<T> 。 您現在已經有了一個可以用於所有選項/設置驗證器的基礎。 對於以下設置：

public class FooSettings
{
    public string Bar { get; set; }
}

你最終得到一個典型的驗證器：

public class FooSettingsValidator : AbstractOptionsValidator<FooSettings>, IFooSettingsValidator
{
    public FooSettingsValidator()
    {
        RuleFor(x => x.Bar).NotEmpty();
    }
}

讓 DI 容器知道它：

serviceCollection.AddSingleton<IValidateOptions<FooSettings>, FooSettingsValidator>();

如果沒有任何內置功能可以執行上述操作，我希望 Scrutor 將其變成一個自動過程。

以上所有內容為我提供了使用 FluentValidation 的所有好處，同時利用了 Microsoft 為我們提供的第一個 class 選項驗證支持。

LINQPad 工作示例：

using static FluentAssertions.FluentActions;

void Main()
{
    var fixture = new Fixture();
    var validator = new FooSettingsValidator();
    validator.Validate(fixture.Build<FooSettings>().Without(x => x.Bar).Create()).Errors.Select(x => x.ErrorMessage).Should().BeEquivalentTo(new string[] { "'Bar' must not be empty." });
    validator.Validate(fixture.Build<FooSettings>().Create()).Errors.Select(x => x.ErrorMessage).Should().BeEquivalentTo(new string[] { });

    using (var scope = ServiceProvider.Create(bar: null).CreateScope())
    {
        Invoking(() => scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FooSettings>>().Value).Should().Throw<OptionsValidationException>();
    }

    using (var scope = ServiceProvider.Create(bar: "asdf").CreateScope())
    {
        scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FooSettings>>().Value.Bar.Should().Be("asdf");
    }
}

// You can define other methods, fields, classes and namespaces here
public class FooSettings
{
    public string Bar { get; set; }
}

public interface IFooSettingsValidator : IValidator { }

public class FooSettingsValidator : AbstractOptionsValidator<FooSettings>, IFooSettingsValidator
{
    public FooSettingsValidator()
    {
        RuleFor(x => x.Bar).NotEmpty();
    }
}

public abstract class AbstractOptionsValidator<T> : AbstractValidator<T>, IValidateOptions<T>
    where T : class
{
    public virtual ValidateOptionsResult Validate(string name, T options)
    {
        var validateResult = this.Validate(options);
        return validateResult.IsValid ? ValidateOptionsResult.Success : ValidateOptionsResult.Fail(validateResult.Errors.Select(x => x.ErrorMessage));
    }
}

public class ServiceProvider
{
    public static IServiceProvider Create(string bar)
    {
        var serviceCollection = new ServiceCollection();

        var config = new ConfigurationBuilder()
                    .AddInMemoryCollection(
                        new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>("Foo:Bar", bar) })
                    .Build();
        serviceCollection.AddSingleton<IConfiguration>(config);
        serviceCollection.AddOptions();
        //serviceCollection.Configure<FooSettings>(config.GetSection("Foo"));
        serviceCollection.AddOptions<FooSettings>()
                            .Bind(config.GetSection("Foo"));

        serviceCollection.AddSingleton<IValidateOptions<FooSettings>, FooSettingsValidator>();
        serviceCollection.AddSingleton<IFooSettingsValidator, FooSettingsValidator>();

        return serviceCollection.BuildServiceProvider();
    }
}