Configuration In ASP.NET Core

{  
    "status" : "This Status read from appSettings.json file",  
    "ConnectionStrings": {  
        "DefaultConnection": "Server=.\\sqlexpress;Database=Test;Trusted_Connection=True;MultipleActiveResultSets=true"  
    }  
}

using Microsoft.AspNetCore.Builder;  
using Microsoft.AspNetCore.Http;  
using Microsoft.Extensions.Configuration;  
using Microsoft.Extensions.DependencyInjection;  
  
namespace WebApplication  
{  
    public class Startup {  
        public IConfiguration Configuration { get; set; }  
        public Startup() {   
         var builder = new ConfigurationBuilder()     
            .AddJsonFile("appSettings.json");   
         Configuration = builder.Build();   
        }    
        public void ConfigureServices(IServiceCollection services)  
        {             
            services.AddMvc();  
        }  
        public void Configure(IApplicationBuilder app){  
            app.UseMvc();     
            app.Run(context => {  
                var status = Configuration["status"];   
                var connectionString = Configuration["ConnectionStrings:DefaultConnection"];  
                context.Response.WriteAsync("Default Connection: " + connectionString);  
                context.Response.WriteAsync("<br/>");  
                return context.Response.WriteAsync("Status: "+status);   
            });   
        }  
    }  
}

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

using Microsoft.AspNetCore.Mvc;  
using Microsoft.Extensions.Configuration;  
  
public class HomeController : Controller  
{  
    IConfiguration _configuration;  
    public HomeController(IConfiguration configuration)  
    {  
        _configuration = configuration;  
    }  
    [Route("home/index")]  
    public IActionResult Index()  
    {  
        ViewBag.connectionstring = _configuration["ConnectionStrings:DefaultConnection"];  
        return View();  
    }  
}

Output

Get Configuration object using options pattern

The Options pattern enables us to use custom option classes to represent a group of related settings. The Option class must have a public read-write property that is defined for each setting and the class must not take any parameters.

The “Microsoft.Extensions.Options.ConfigurationExtensions” dependency contains the extension method for IServiceCollection.Configure. We need to add this dependency in project.json file.

1. "Microsoft.Extensions.Options.ConfigurationExtensions": "1.0.0"

Here, I have defined my model and I am using same appSetting.json that was used in previous example. In this example, I have bound the connection string setting of appSetting.json with my model class.

public class ConnectionString   
{  
    public ConnectionString()  
    {  
    }  
    public string DefaultConnection { get; set; }  
    public string MainDBConnectionString { get; set; }  
}

In the following code, IConfigureOptions<TOptions> service is added to the Service Container. It binds ConnectionStrings class to the section "ConnectionStrings" of the appsettings.json file.

Startup.cs

public void ConfigureServices(IServiceCollection services)  
{
    services.AddOptions();     
    //Configure Option using Extensions method  
    services.Configure<ConnectionString>(Configuration.GetSection("ConnectionStrings"));     
    services.AddSingleton<IConfiguration>(Configuration);  
    services.AddMvc();  
}

Using IOptions<TOptions> accessor service, we can inject Options into our application. To setup the IOptions<TOptions> service, we need to call "AddOptions" extension method during startup in our ConfigureServices method of Startup class.

HomeController.cs

using Microsoft.AspNetCore.Mvc;  
using Microsoft.Extensions.Options;  
  
public class HomeController : Controller  
{  
    ConnectionString _connectionstring;  
    public HomeController(IOptions<ConnectionString> connectionstringAccessor)  
    {  
        _connectionstring = connectionstringAccessor.Value;  
    }  
    [Route("home/index")]  
    public IActionResult Index()  
    {  
        ViewBag.connectionstring = _connectionstring.DefaultConnection;  
        return View();  
    }  
}

Output

Working with In-memory provider

The new configuration framework of ASP.NET Core does also supports in-memory configuration. In this type of configuration, the values are directly stored into the code and the later part of the application uses this configuration. Following is a sample that shows how to use the in-memory provider and bind to a class.

public Startup()  
{  
    var builder = new ConfigurationBuilder();  
  
    var dic = new Dictionary<string, string>  
    {  
        {"Profile:FirstName", "Jignesh"},  
        {"Profile:LastName", "Trivedi"},  
        {"Profile:Designation", "PL"}  
    };  
    builder.AddInMemoryCollection(dic);  
    Configuration = builder.Build();  
}

Using Configuration["Profile:FirstName"], we can get the value of firstname of profile configuration. We can also bind this value with custom model. Her,e I have created the following “Profile” class to bind this profile value.

public class Profile  
{  
    public string FirstName { get; set;}  
    public string LastName { get; set;}  
    public string Designation { get; set;}  
}

The following sample shows how to bind to a profile and use the options pattern with ASP.NET Core MVC application.

Startup.cs

public void ConfigureServices(IServiceCollection services)  
{  
    services.AddOptions();  
    services.Configure<Profile>(Configuration.GetSection("Profile"));  
    services.AddMvc();  
}

HomeController.cs

using Microsoft.AspNetCore.Mvc;  
using Microsoft.Extensions.Configuration;  
using Microsoft.Extensions.Options;  
  
public class HomeController : Controller  
{  
    Profile _profile;  
    public HomeController(IOptions<Profile> Profile)  
    {  
        _profile = Profile.Value;  
    }  
    [Route("home/index")]  
    public IActionResult Index()  
    {  
        ViewBag.FirstName = _profile.FirstName;  
        return View();  
    }  
}

Summary

ASP.NET Core provides a flexible configuration model that supports a number of different ways to work with configuration, like file-based, in-memory, and environment variables. This also supports the options model so that we can strongly inject settings to our application.