How to validate configuration settings using IValidateOptions in ASP.NET Core 2.2?

Question

Microsoft's ASP.NET Core documentation briefly mentions that you can implement IValidateOptions<TOptions> to validate configuration settings from appsettings.json, but a complete example is not provided. How is IValidateOptions intended to be used? More specifically:

• Where do you wire up your validator class?
• How can you log a useful message explaining what the problem is if validation fails?

I have actually found a solution already. I'm posting my code since I can't find any mention of IValidateOptions on Stack Overflow at this time.

Answer 1

I eventually found an example of how this is done in the commit where the options validation feature was added. As with so many things in asp.net core, the answer is to add your validator to the DI container and it will automatically be used.

With this approach the PolygonConfiguration goes into the DI container after validation and can be injected into the controllers that need it. I prefer this to injecting IOptions<PolygonConfiguration> into my controllers.

It appears that the validation code runs the first time an instance of PolygonConfiguration is requested from the container (i.e. when the controller is instantiated). It might be nice to validate earlier during startup, but I'm satisfied with this for now.

Here's what I ended up doing:

public class Startup
{
    public Startup(
        IConfiguration configuration,
        ILoggerFactory loggerFactory)
    {
        Configuration = configuration;
        Logger = loggerFactory.CreateLogger<Startup>();
    }

    public IConfiguration Configuration { get; }
    private ILogger<Startup> Logger { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

        //Bind configuration settings
        services.Configure<PolygonConfiguration>(
            Configuration.GetSection(nameof(PolygonConfiguration)));

        //Add validator
        services.AddSingleton<
            IValidateOptions<PolygonConfiguration>, 
            PolygonConfigurationValidator>();

        //Validate configuration and add to DI container
        services.AddSingleton<PolygonConfiguration>(container =>
        {
            try
            {
                return container
                    .GetService<IOptions<PolygonConfiguration>>()
                    .Value;
            }
            catch (OptionsValidationException ex)
            {
                foreach (var validationFailure in ex.Failures)
                    Logger.LogError(
                        $"appSettings section "
                        + "'{nameof(PolygonConfiguration)}' "
                        + "failed validation. Reason: "
                        + "{validationFailure}");

                throw;
            }
        });
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
       ...
    }
}

appSettings.json with some valid and invalid values

{
  "PolygonConfiguration": {
    "SupportedPolygons": [
      {
        "Description": "Triangle",
        "NumberOfSides": 3
      },
      {
        "Description": "Invalid",
        "NumberOfSides": -1
      },
      {
        "Description": "",
        "NumberOfSides": 6
      }
    ]
  }
}

The validator class itself

    public class PolygonConfigurationValidator
        : IValidateOptions<PolygonConfiguration>
    {
        public ValidateOptionsResult Validate(
            string name,
            PolygonConfiguration options)
        {
            if (options is null)
                return ValidateOptionsResult.Fail(
                    "Configuration object is null.");

            if (options.SupportedPolygons is null 
                || options.SupportedPolygons.Count == 0)
                return ValidateOptionsResult.Fail(
                    $"{nameof(PolygonConfiguration.SupportedPolygons)} "
                    + "collection must contain at least one element.");

            foreach (var polygon in options.SupportedPolygons)
            {
                if (string.IsNullOrWhiteSpace(polygon.Description))
                    return ValidateOptionsResult.Fail(
                        $"Property '{nameof(Polygon.Description)}' "
                        + "cannot be blank.");

                if (polygon.NumberOfSides < 3)
                    return ValidateOptionsResult.Fail(
                        $"Property '{nameof(Polygon.NumberOfSides)}' "
                        + "must be at least 3.");
            }

            return ValidateOptionsResult.Success;
        }
    }

And the configuration models

    public class Polygon
    {
        public string Description { get; set; }
        public int NumberOfSides { get; set; }
    }

    public class PolygonConfiguration
    {
        public List<Polygon> SupportedPolygons { get; set; }
    }