Crip.Extensions.ConfigLocator 1.4.0

ConfigLocator

Crip.Extensions.ConfigLocator helps ASP.NET Core apps register options classes automatically.

Instead of writing services.Configure<TOptions>(...) for every class, mark your options with an attribute and let the library do the wiring.

What it does

• Finds options classes in your assemblies
• Binds them to configuration sections
• Supports validation
• Can bind more than one type from the same section

Quick start

Install the package:

dotnet add package Crip.Extensions.ConfigLocator

Register it in Program.cs:

using Crip.Extensions.ConfigLocator;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddConfigLocator(builder.Configuration);

Define an options class

using Crip.Extensions.ConfigLocator;

[ConfigLocation("ExternalServices:GitHub")]
public class GitHubOptions
{
    public string ApiKey { get; set; } = string.Empty;
    public int TimeoutSeconds { get; set; } = 30;
}

This maps to appsettings.json:

{
  "ExternalServices": {
    "GitHub": {
      "ApiKey": "your-api-key",
      "TimeoutSeconds": 60
    }
  }
}

Use it like any other ASP.NET Core options class:

public class GitHubService(IOptions<GitHubOptions> options)
{
    private readonly GitHubOptions _options = options.Value;

    public void DoSomething() => Console.WriteLine(_options.ApiKey);
}

Validation

You can use standard data annotations or a custom validator.

Data annotations

[ConfigLocation("MySection")]
[ConfigValidate]
public class MyOptions
{
    [Required, MinLength(5)]
    public string ApiKey { get; set; } = null!;
}

Custom validator

public class MyOptionsValidator : IValidateOptions<MyOptions>
{
    public ValidateOptionsResult Validate(string? name, MyOptions options)
    {
        if (options.ApiKey == "default")
            return ValidateOptionsResult.Fail("API Key cannot be 'default'");

        return ValidateOptionsResult.Success;
    }
}

[ConfigLocation("MySection")]
[ConfigValidate<MyOptionsValidator>]
public class MyOptions
{
    public string ApiKey { get; set; } = null!;
}

// For older C# versions, use:
// [ConfigValidate(typeof(MyOptionsValidator))]

More than one type

You can bind multiple types to the same section:

[ConfigLocation("ServiceSettings", typeof(AdditionalOptions))]
public class MainOptions
{
    // ...
}

Named options

You can register the same options class more than once by giving each registration a name:

[ConfigLocation("GitHub:Default")]
[ConfigLocation("GitHub:Tenants:Europe", "europe")]
[ConfigLocation("GitHub:Tenants:Us", "us")]
public class GitHubOptions
{
    public string ApiKey { get; set; } = string.Empty;
}

Then resolve a specific named instance:

public class GitHubClient(IOptionsMonitor<GitHubOptions> options)
{
    private readonly GitHubOptions _europe = options.Get("europe");
    private readonly GitHubOptions _us = options.Get("us");
}

Limitations

• Only non-abstract classes are scanned
• Binding requires a public parameterless constructor

More info

• Options pattern in ASP.NET Core (Official Docs)