ParametrizedConfiguration 1.2.0

ParametrizedConfiguration

An ASP .NET Core class library presents a configuration provider that uses either it`s own configuration data via other providers or environment variables to parametrize parameter placeholders with values, accessed by parameter keys. By default placeholders defined between two % symbols like %param name%, where param name should be either the key of the same configuration or environment variable name, the value of which will be substituted into %param name%.

For example, this configuration described as a json:

{
  "param1": "1+%param2%",
  "param2": "2+%param3%",
  "param3": "3"
}

will be parametrized into this:

{
  "param1": "1+2+3",
  "param2": "2+3",
  "param3": "3"
}

We also may use environment variables over configuration parameters:

Environment.SetEnvironmentVariable("param3", "?");

{
  "param1": "1+2+?",
  "param2": "2+?",
  "param3": "3"
}

This can be used to hide sensitive data from publicly stored configurations or to reuse the same values in different parts of the configuration.

Installation:

• from NuGet;
• from package manager console:

Install-Package ParametrizedConfiguration

• from command line:

dotnet add package ParametrizedConfiguration

Usage:

Parametrization will be made on any configuration that registered ParametrizedConfigurationProvider. The registration is made by calling WithParametrization() extension method on configuration builder.

var configuration = new ConfigurationBuilder()
    // ...Here will be listed all configuration providers (at least one)...
    .WithParametrization() // Parametrized provider registered here as last one
    .Build();

Examples:

Here is a simple example to demonstrate configuration parametrization:

using Microsoft.Extensions.Configuration;
using ConfigurationRepository;

// Assume secrets are set via environment variables somewere outside this code,
// we set them here just for clarity.
Environment.SetEnvironmentVariable("UserName", "Bob");
Environment.SetEnvironmentVariable("Password", "strongPassword");

// Let`s define our simple configuration with parameters using in-memory configuration.
// In production code we will store our configuration in json files or other sources.
Dictionary<string, string?> inMemoryDict = new()
{

    {
        "DatabaseName",
        "MyDatabase"
    },
    {
        "ConnectionStrings:Mssql",
        "Server=mssql-server;Database=%DatabaseName%;User Id=%UserName%;Password=%Password%;TrustServerCertificate=True"
    }
};

// Define that configuration with parametrization provider:
var configuration = new ConfigurationBuilder()
    .AddInMemoryCollection(inMemoryDict)
    .WithParametrization()
    .Build();

// Ok, now let`s get the connection string from configuration:
Console.WriteLine(configuration.GetConnectionString("mssql"));

// Output will be parametrized with values from both configuration and environment variables:
// Server=mssql-server;Database=MyDatabase;User Id=Bob;Password=strongPassword;TrustServerCertificate=True

This example you may also find in ParametrizedConfiguration.EnvSecrets sample project on github.