This library registers and configures services in a service collection using .NET's' configuration library.

Given an application with the following ConfigureServices section:

services.AddLogging();
services.AddHsts(options =>
{
   options.ExcludedHosts.Clear();
   options.Preload = true;
   options.IncludeSubDomains = true;
   options.MaxAge = TimeSpan.FromDays(365);
});
services.Configure<CookiePolicyOptions>(options =>
{
   options.HttpOnly = HttpOnlyPolicy.Always;
   options.Secure = CookieSecurePolicy.Always;
});

The ConfigureServices method above can be moved into the configuration using the following code and appsettings.config configuration:

// .NET 5.0, .NET Core 3.1 and below using ConfigurationProcessor.DependencyInjection
services.AddFromConfiguration(Configuration, "Services");

// .NET 6.0 with ConfigurationProcessor.AspNetCore
var builder = WebApplication.CreateBuilder(args);
builder.AddFromConfiguration("Services");

{
   "Services": {
      "Logging": true,
      "Hsts": {
         "ExcludedHosts": {
            "Clear": true
         },
         "Preload": true,
         "IncludeSubDomains": true,
         "MaxAge": "356.00:00:00"
      },
      "Configure<Microsoft.AspNetCore.Builder.CookiePolicyOptions>": {
         "HttpOnly": "Always",
         "Secure": "Always"
      }
   }
}

Since we are using IConfiguration, we aren't limited to the appsettings.json for configuring our services. We can also have the configuration in environment variables, in command-line arguments or with custom configuration providers such as AWS Secrets Manager.

The library works by using reflection and scanning all currently loaded assemblies for extension methods for IServiceCollection. This project was inspired by the Serilog.Settings.Configuration project.

Given a configuration named MyService, an extension method named AddMyService or MyService will be filtered from the candidate extension methods. If multiple candidates are found, the best overload will be chosen based on the name of the input parameters.

Given the following extension methods:

public IServiceCollection AddMyService(this IServiceCollection services);
public IServiceCollection AddMyService(this IServiceCollection services, string name);
public IServiceCollection AddMyService(this IServiceCollection services, int count);

When given the configuration below, the extension method AddMyService(IServiceCollection, int) is chosen.

{
   "Services": {
      "MyService" : {
         "Count": 23
      }
   }
}

If the extension method is parameterless, use true instead of an object. The configuration method below will choose AddMyService(IServiceCollection). A false value will prevent registration.

{
   "Services": {
      "MyService" : true
   }
}

ConfigurationProcessor can be used with extension methods that use a generic action delegate. Generic arguments type of System.Object is not supported.

Given the extension method below:

public IServiceCollection AddMyService(this IServiceCollection services, Action<MyServiceOptions> configureOptions);

public class MyServiceOptions
{
   public string Title { get; set; }
}

The configuration below is equivalent to calling services.AddMyService(options => {});:

{
   "MyService" : true
}

The configuration below is equivalent to calling services.AddMyService(options => { options.Title = "Mr" });:

{
   "MyService" : {
      "Title": "Mr"
   }
}

When the action delegates with more than one argument, all matching configuration methods will be called.

Given the extension method below:

public IServiceCollection AddMyService(this IServiceCollection services, Action<MyServiceOptions, MyOtherServiceOptions> configureOptions);

public class MyServiceOptions
{
   public string Title { get; set; }
   public string Name
}

public class MyOtherServiceOptions
{
   public string Title { get; set; }
}

The configuration below is equivalent to calling services.AddMyService((options, other) => { options.Title = "Mr"; options.Name = "John"; other.Title = "Mr"; });:

{
   "MyService" : {
      "Title": "Mr",
      "Name": "John"
   }
}

Generic extension methods can be mapped by supplying the generic parameter via the angle brackets <>. The full name of the type must be supplied.

public IServiceCollection AddMyService<T>(this IServiceCollection services, T value);

{
   "MyService<System.String>" : {
      "Value": "hello world"
   }
}

Extension methods that have a single array parameter can be mapped with json arrays. This will work with or without the params keyword. This can also work with a List<> parameter type.

public IServiceCollection AddMyService(this IServiceCollection services, params string[] values);

{
   "MyService" : [
      "salut",
      "hi",
      "konnichiwa"
   ]
}

Extension methods that have a single dictionary parameter can be mapped with json objects. Currently, only the parameter type Dictionary<,> is supported. If one of the property names matches with a parameter name in an extension method overload, the overload with the matching parameter name is chosen instead of the dictionary overload.

public IServiceCollection AddMyService(this IServiceCollection services, Dictionary<string, int> values);

{
   "MyService" : {
      "Value1": 1,
      "Value2": 2
   }
}

Some .NET types can be mapped from a string in configuration.

*For Type and Assembly, the loaded types and assemblies are searched first before resorting to Type.GetType or Assembly.Load.

A parameter/property type that is a delegate can be mapped to a static method.

namespace MyProject
{
   public static class Helpers
   {
      public IServiceCollection AddMyService(
         this IServiceCollection services,
         Action<MyConfiguration> configureAction);

      public static void LogOnError(ILogger instance, MyConfiguration configuration);
   }

   public class MyConfiguration
   {
      public Action<ILogger, MyConfiguration> OnError { get; set; }
   }
}

The configuration below maps to services.AddMyService(config => config.OnError = Helpers.LogOnError)

{
   "MyService" : {
      "OnError": "MyProject.Helpers::LogOnError"
   }
}

ConfigurationProcessor uses IConfiguration.GetChildren() to retrieve the methods to execute. The configuration key names are sorted alphabetically, and there is no supported mechanism to retrieve the original sort order.

Given the configuration below:

{
   "MyService" : {
      "ConfigureB": { "Value": 1 },
      "ConfigureZ": { "Value": 5 },
      "ConfigureA": { "Value": 4 }
   }
}

The order of the methods executed will be ConfigureA, ConfigureB and then ConfigureZ;

Parameters or properties that are named 'ConnectionString' are given special handling where the value will come from an element from ConnectionStrings section with the same key if it exists.

Given the configuration below:

{
   "ConnectionStrings": {
      "Default": "abcd"
   },
   "Services": {
      "DbConnection": {
         "ConnectionString" : "Default"
      }
   }
}

public static IServiceCollection AddDbConnection(this IServiceCollection services, string connectionString)

The configuration above is equivalent to calling services.AddDbConnection("abcd");

Serilog.Settings.Configuration which is the basis for this project.