ASP.NET 5 (vNext) - Getting a Configuration Setting

Question

I'm writing a basic app to learn ASP.NET 5. One area I find very confusing is configuration. Prior to ASP.NET 5, I could do the following:

var settingValue = ConfigurationManager.AppSettings["SomeKey"];

I would have lines of code like that sprinkled throughout my code. Now, in the vNext world, I have a config.json file that looks like this:

config.json

{
  "AppSettings": {
    "SomeKey":"SomeValue"
  }
}

Then in Startup.cs, I have the following: Startup.cs

public IConfiguration Configuration { get; set; }
public Startup(IHostingEnvironment environment) 
{
  Configuration = new Configuration()
      .AddJsonFile("config.json");
}

From there, I'm totally stumped. I have MyClass.cs in /src/Website/Code/Models/MyClass.cs.

MyClass.cs

public class MyClass
{
  public string DoSomething() 
  {
    var result = string.Empty;
    var keyValue = string.Empty; // TODO: What do I do here? How do I get the value of "AppSettings:SomeKey"?
    return result;
  }
}

How do I get the value of "AppSettings:SomeKey"?

Answer 1

ASP.NET 5 makes heavy use of Dependency Injection, so if you are also using Dependency Injection then this is very simple. If you examine the sample MVC6 project, you can see how this works:

First, there's a class AppSettings defined in Properties, which is a strongly-typed version of the options your class supports. In the sample project, this just contains SiteTitle.

public class AppSettings
{
    public string SiteTitle { get; set; }
}

Then, this class is initialised through dependency injection in ConfigureServices. Configuration here is the one you created in the constructor of the Startup class.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<AppSettings>(Configuration.GetSubKey("AppSettings"));
    // ...
}

Then, assuming your class is instantiated by the dependency injection container, you can simply ask for an IOptions and you'll get one. For example, in a controller you could have the following:

public class HomeController
{
    private string _title;
    public HomeController(IOptions<AppSettings> settings) 
    {
        _title = settings.Options.SiteTitle;
    }
}

Answer 2

I use ASP.NET 5 dependency injection, like so.

config.json:

{
    "random":  "Hello World!"
}

startup.cs:

public class Startup
{
    public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
    {
        var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
            .AddJsonFile("config.json");

        Configuration = builder.Build();
    }

    public IConfiguration Configuration { get; set; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc();
        services.AddSingleton<IConfiguration>(sp => { return Configuration; });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseMvc(routes =>
        {
            routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}");
        });

    }

}

Controller:

public class HomeController : Controller
{

    IConfiguration config;

    public HomeController(IConfiguration config)
    {
        this.config = config;
    }

    public IActionResult Index()
    {
        var template = "<marquee>{0}</marquee>";
        var content = string.Format(template, config.Get("random"));
        return Content(content, "text/html");
    }
}

Answer 3

I highly recommend using the OptionsModel instead of reading the configuration directly. It allows strong typed model binding to configuration.

Here is an example: GitHub.com/aspnet/Options/test/Microsoft.Extensions.Options.Test/OptionsTest.cs

For your particular case create a model:

class AppSettings {
    public string SomeSetting {get;set;}
}

and then bind it to your configuration:

var config = // The configuration object
var options = ConfigurationBinder.Bind<AppSettings>(config); 
Console.WriteLine(options.SomeSetting);

That way you don't have to worry from where the setting comes from, how it is stored or what is the structure. You simply predefine your options model and magic happens.

Answer 4

Use this:

var value = Configuration.Get("AppSettings:SomeKey");

Based on this blog post. The colon is similar to dot notation and is used for navigation down the hierarchy.

If you need the value in other classes, you should inject it in. ASP.NET has built in dependency injection, but if you just need one instance of MyClass you can new it up instead of setting up a DI container.

public IConfiguration Configuration { get; set; }

public Startup(IHostingEnvironment environment) 
{
    Configuration = new Configuration()
      .AddJsonFile("config.json");
    //generally here you'd set up your DI container. But for now we'll just new it up
    MyClass c = new MyClass(Configuration.Get("AppSettings:SomeKey"));
}

public class MyClass
{
    private readonly string Setting; //if you need to pass multiple objects, use a custom POCO (and interface) instead of a string.

    public MyClass(string setting) //This is called constructor injection
    {
        Setting = setting;
    }

    public string DoSomething() 
    {
        var result = string.Empty;
        //Use setting here
        return result;
    }
}