How to write fluent validation rules inside IValidateOptions using FluentValidation?

I have a strong preference to utilise the same approach for validation across the stack, and in my case this is via FluentValidation. The following would be my approach.

Create a new base validator for your options/settings validators:

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

This extends the FluentValidation AbstractValidator<T> to support IValidateOptions<T>. You've now got a base that you can use for all of your options/settings validators. For the following settings:

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

you end up with a typical validator:

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

Let the DI container know about it:

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

If there is nothing built in to do the above, I'd look to Scrutor to turn this into an automatic process.

All of the above affords me all of the benefits of using FluentValidation, whilst utilising the first class options validation support that Microsoft has provided for us.

LINQPad working example:

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

I found below code in this article 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();  
}  

This way you can have all you validation in implementation of AbstractValidator and it will be simpler than you current implementation. Using this you don't need to implement IOptionsValidator I guess. The article has a good explanation so refer to get more insights.

I can simplify using the System.ComponentModel.DataAnnotations

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

then you can customize your BadRequest via the pipeline

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

more information https://docs.microsoft.com/en-us/aspnet/core/mvc/models/validation?view=aspnetcore-5.0