appsettings.json in ASP.net Core 2.0 Preview configuration GetSection null

Question

I was trying to call GetSection from injected configuration in the Startup.cs. The Value was null, while indexer to a concret

Answer 1

I first checked to see if there were any changes between 1.1.1 and 2.x of JsonConfigurationProvider.cs, the internal code that ultimately constructs retrievable values from your JSON file. There were no changes to this or any of the other code that ultimately gets called by your this.Configuration.GetSection("MyConfig");.

The way retrieving values works is that the Configuration will look for your key MyConfig in each config provider in reverse order as defined in code until a value is found. In your example, providers (json, envionment variables, command line args) are provided within Webhost.CreateDefaultBuilder() (see here).

Looking at the code for JsonConfigurationFileParser.cs, it builds a Dictionary<string, string> for keys and values, but only for primitive values. That is, no key is stored for MyConfig (at this level it is an object), but there will be a key for MyConfig:ConfigA, and array values would look like MyConfig:ConfigA:0, MyConfig:ConfigA:1, etc.

Lastly, you will find that Configuration.GetSection("MyConfig") always returns you a newly constructed ConfigurationSection that is never null, and at the very worst will have a Value property of null.

So what happens when you hover over a ConfigurationSection with Intellisense and look at the Value property is that every config provider had been searched and none was found to have a key of "MyConfig" with a primitive value converted to string to return.

You will at the very least need to call:

services.Configure<MyConfigOptions>(configuration.GetSection("MyConfig"));
services.AddSingleton(cfg => cfg.GetService<IOptions<MyConfigOptions>>().Value);

to have it injected throughout your app as a C# object. Otherwise, call individual values with the colon ["MyConfig:ConfigA"] separator syntax or with var mySection = this.Configuration.GetSection("MyConfig")["ConfigA"];, which is redundant but illustrates it is only used to retrieve primitives.

To bind to C# objects and inject them, I created the following extension method:

public static class IServiceCollectionExtensions
{
    public static IServiceCollection AddConfigOptions<TOptions>(this IServiceCollection services,
        IConfiguration configuration, string section) where TOptions : class, new()
    {
        services.Configure<TOptions>(configuration.GetSection(section));
        services.AddSingleton(cfg => cfg.GetService<IOptions<TOptions>>().Value);
        return services;
    }
}

which can be called like this:

public class Startup
{
    public Startup(IConfiguration configuration) => Configuration = configuration;

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddConfigOptions<EmailOptions>(Configuration, "Email")

and injected like this:

public class EmailSender : IEmailSender
{
    private EmailOptions _emailOptions;

    public EmailSender(EmailOptions options) => _emailOptions = options;

Answer 2

In my case, I was missing a package:

Microsoft.Extensions.Configuration.Binder

It's in fact documented as a subtle code comment in here

Answer 3

I found AspNetCore 2.0 to be so much simpler than 1.x in terms of configuration.

If you put a breakpoint in the Startup(IConfiguration configuration) constructor, you'll notice that the configuration variable has about 5 providers.

The JsonConfigurationProvider is the provider you're interested in for the appsettings.json file, but you will probably notice that the Data property has a Count=0. That is most likely due to the fact that your application is looking for the appsettings.json file in the directory specified in the JsonConfigurationProvider.Source.FileProvider.Root (which is by default wwwroot).

All I did was add an MSBuild task in the .csproj file as follows:

<Copy SourceFiles="appsettings.json" DestinationFolder="wwwroot" />

And that seemed to work perfectly.

This is obviously useful during local development only. However, the general practice these days is never to have configuration in a file in the first place, especially since it will end up being part of your repo history. Instead, when deploying your app, the two common practices these days are using environment variables to override your values, or even better using a key/value store like consul.

Moreover, I see a whole bunch of fancy examples online on how to use the services.Configure<>() which is fine, but the Startup.cs already uses DI to inject values to IConfiguration configuration. That means that IConfiguration is already registered in .NET core's IoC Container, so that essentially means you can already use IConfiguration in any other class in your app like so:

public JobsRepository(IConfiguration configuration)
{
    this.configA = configuration.GetSection("MyConfig:ConfigA").Value;
}