464

I have set up my AppSettings data in file appsettings/Config .json like this:

{
  "AppSettings": {
        "token": "1234"
    }
}

I have searched online on how to read AppSettings values from .json file, but I could not get anything useful.

I tried:

var configuration = new Configuration();
var appSettings = configuration.Get("AppSettings"); // null
var token = configuration.Get("token"); // null

I know with ASP.NET 4.0 you can do this:

System.Configuration.ConfigurationManager.AppSettings["token"];

But how do I do this in ASP.NET Core?

4

29 Answers 29

487

This has had a few twists and turns. I've modified this answer to be up to date with ASP.NET Core 2.0 (as of 26/02/2018).

This is mostly taken from the official documentation:

To work with settings in your ASP.NET application, it is recommended that you only instantiate a Configuration in your application’s Startup class. Then, use the Options pattern to access individual settings. Let's say we have an appsettings.json file that looks like this:

{
  "MyConfig": {
   "ApplicationName": "MyApp",
   "Version": "1.0.0"
   }

}

And we have a POCO object representing the configuration:

public class MyConfig
{
    public string ApplicationName { get; set; }
    public int Version { get; set; }
}

Now we build the configuration in Startup.cs:

public class Startup 
{
    public IConfigurationRoot Configuration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

        Configuration = builder.Build();
    }
}

Note that appsettings.json will be registered by default in .NET Core 2.0. We can also register an appsettings.{Environment}.json config file per environment if needed.

If we want to inject our configuration to our controllers, we'll need to register it with the runtime. We do so via Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    // Add functionality to inject IOptions<T>
    services.AddOptions();

    // Add our Config object so it can be injected
    services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
}

And we inject it like this:

public class HomeController : Controller
{
    private readonly IOptions<MyConfig> config;

    public HomeController(IOptions<MyConfig> config)
    {
        this.config = config;
    }

    // GET: /<controller>/
    public IActionResult Index() => View(config.Value);
}

The full Startup class:

public class Startup 
{
    public IConfigurationRoot Configuration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

        Configuration = builder.Build();
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc();

        // Add functionality to inject IOptions<T>
        services.AddOptions();

        // Add our Config object so it can be injected
        services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
    }
}
Sign up to request clarification or add additional context in comments.

32 Comments

version "1.0.0-beta4" works on mine not "1.0.0-alpha4". Thanks a lot!
After adding the nuget Microsoft.Extensions.Options.ConfigurationExtensions it worked as expected.
this code vs old xml > how many of you have time for this, just to save a string?
Nice explanation of the config process logic, but it misses a major point: SetBasePath() and AddJsonFile() are extension methods, berried deeply in the framework in separate assemblies. So in order to get started, one needs to install Microsoft.Extensions.Configuration.FileExtensions and Microsoft.Extensions.Configuration.Json in addition to Microsoft.Extensions.Configuration.
Absolutely incredible how convoluted it is just to retrieve an application setting.
|
182

.NET Core 3.0 / .NET 6

This is a sleek and simple solution.

File appsettings.json

{
    "ConnectionStrings": {
        "DefaultConnection": "****;"
    },
    "AppSettings": {
        "APP_Name": "MY_Service",
        "SampleIntValue": 100
    }
}

Controller:

On top:

using Microsoft.Extensions.Configuration;

In your code:

VAR 1:

var AppName = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build().GetSection("AppSettings")["APP_Name"];

or

VAR 2: (For reading multiple values or numbers)

var MyConfig = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
    var IntExample = MyConfig.GetValue<int>("AppSettings:SampleIntValue");
    var AppName = MyConfig.GetValue<string>("AppSettings:APP_Name");

11 Comments

@Essej: You need to install the Microsoft.Extensions.Configuration.Json nuget package in order to use the AddJsonFile methode.
The only method I've found that works in a .Net Core Program.cs file. Have to agree with a comment on a different answer: so much convolution just to get a settings file.
OMG thank you for this! The missing piece that none of the others provided was how to access the settings, e.g. .GetSection("AppSettings")["APP_Name"]
sidestepping the application host framework is sometimes the best way to go, for some simple console applications for example, thanks for the answer
Finally a simple solution, thanks. WHY has msft made this so difficult in Core??
|
79

First off: The assembly name and namespace of Microsoft.Framework.ConfigurationModel has changed to Microsoft.Framework.Configuration. So you should use: e.g.

"Microsoft.Framework.Configuration.Json": "1.0.0-beta7"

as a dependency in project.json. Use beta5 or 6 if you don't have 7 installed. Then you can do something like this in Startup.cs.

public IConfiguration Configuration { get; set; }

public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
     var configurationBuilder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
        .AddJsonFile("config.json")
        .AddEnvironmentVariables();
     Configuration = configurationBuilder.Build();
}

If you then want to retrieve a variable from the config.json you can get it right away using:

public void Configure(IApplicationBuilder app)
{
    // Add .Value to get the token string
    var token = Configuration.GetSection("AppSettings:token");
    app.Run(async (context) =>
    {
        await context.Response.WriteAsync("This is a token with key (" + token.Key + ") " + token.Value);
    });
}

or you can create a class called AppSettings like this:

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

and configure the services like this:

public void ConfigureServices(IServiceCollection services)
{       
    services.AddMvc();

    services.Configure<MvcOptions>(options =>
    {
        //mvc options
    });

    services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
}

and then access it through e.g. a controller like this:

public class HomeController : Controller
{
    private string _token;

    public HomeController(IOptions<AppSettings> settings)
    {
        _token = settings.Options.token;
    }
}

2 Comments

can you please share configuration json for "AppSettings" for reference
I need entire appSettings.json configs in class, for this, I have designed class as per JSON and use Configuration.Get<AppSettings>() to deserialize entire file instead of a specific section.
71

For .NET Core 2.0, things have changed a little bit. The startup constructor takes a Configuration object as a parameter, So using the ConfigurationBuilder is not required. Here is mine:

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}

public IConfiguration Configuration { get; }

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.Configure<StorageOptions>(Configuration.GetSection("AzureStorageConfig"));
}

My POCO is the StorageOptions object mentioned at the top:

namespace FictionalWebApp.Models
{
    public class StorageOptions
    {
        public String StorageConnectionString { get; set; }
        public String AccountName { get; set; }
        public String AccountKey { get; set; }
        public String DefaultEndpointsProtocol { get; set; }
        public String EndpointSuffix { get; set; }

        public StorageOptions() { }
    }
}

And the configuration is actually a subsection of my appsettings.json file, named AzureStorageConfig:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=fictionalwebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },

  "AzureStorageConfig": {
    "AccountName": "fictionalwebapp",
    "AccountKey": "Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==",
    "DefaultEndpointsProtocol": "https",
    "EndpointSuffix": "core.windows.net",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=fictionalwebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
  }
}

The only thing I'll add is that, since the constructor has changed, I haven't tested whether something extra needs to be done for it to load appsettings.<environmentname>.json as opposed to appsettings.json.

7 Comments

Just a note that you still need to toss .AddJsonFile("yourfile.json") to ConfigConfiguration. IE, you need to tell it where the file is. Didn't see that in the answer.
Eric I will retest that, I don't remember adding that line; Could it be necessary only if the name of the json file isn't the default name?
Per MSDN, it is not required for ASPNETCORE 2.0, although it doesnt appear to work for me either. learn.microsoft.com/en-us/dotnet/api/…
I can confirm that I had to build a ConfigurationBuilder() object and call AddJSONFile() to load the appSettings.json files into the config dictionary. This is ASP.NET Core 2.0. Is this a bug as it runs contrary to what MSDN says?
Can you give an example how you inject StorageOptions into your controllers? If I use hug's approach of using dependency injection with public HomeController(IOptions<StorageOptions> settings), I get this error message: Model bound complex types must not be abstract or value types and must have a parameterless constructor.
|
59

With .NET Core 2.2, and in the simplest way possible...

public IActionResult Index([FromServices] IConfiguration config)
{
    var myValue = config.GetValue<string>("MyKey");
}

appsettings.json is automatically loaded and available through either constructor or action injection, and there's a GetSection method on IConfiguration as well. There isn't any need to alter Startup.cs or Program.cs if all you need is appsettings.json.

3 Comments

even simpler: var myValue = config["MyKey"]
... and you can do: config["Storage:ConnectionString"] to get elements inside the json. I can confirm this technique works on .net core 3 and works on construction injection.
and in .net 7 it is working too..
44

If you just want to get the value of the token then use

Configuration["AppSettings:token"]

1 Comment

For this to work, you need to have an IConfiguration instance initialized via ConfigurationBuilder beforehand.
28

I doubt this is good practice but it's working locally. I'll update this if it fails when I publish/deploy (to an IIS web service).

Step 1 - Add this assembly to the top of your class (in my case, controller class):

using Microsoft.Extensions.Configuration;

Step 2 - Add this or something like it:

var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json").Build();

Step 3 - Call your key's value by doing this (returns string):

config["NameOfYourKey"]

2 Comments

i think this should be fine provided the appsettings.json is in the right directory
thank you for me : config["AppSettings:JWT_Secret"]
24

For ASP.NET Core 3.1 you can follow this documentation:

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1

When you create a new ASP.NET Core 3.1 project or .NET 5 project you will have the following configuration line in Program.cs:

Host.CreateDefaultBuilder(args)

This enables the following:

  1. ChainedConfigurationProvider : Adds an existing IConfiguration as a source. In the default configuration case, adds the host configuration and setting it as the first source for the app configuration.
  2. appsettings.json using the JSON configuration provider.
  3. appsettings.Environment.json using the JSON configuration provider. For example, appsettings.Production.json and appsettings.Development.json.
  4. App secrets when the app runs in the Development environment.
  5. Environment variables using the Environment Variables configuration provider.
  6. Command-line arguments using the Command-line configuration provider.

This means you can inject IConfiguration and fetch values with a string key, even nested values. Like IConfiguration ["Parent:Child"];

Example:

appsettings.json

{
  "ApplicationInsights":
    {
        "Instrumentationkey":"putrealikeyhere"
    }
}

WeatherForecast.cs

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;
    private readonly IConfiguration _configuration;

    public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
    {
        _logger = logger;
        _configuration = configuration;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        var key = _configuration["ApplicationInsights:InstrumentationKey"];

        var rng = new Random();
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

2 Comments

@Ogglas...how the caller of WeatherForecastController() could obtain the class that implements IConfiguration?
This worked for me on net 6, yet i didnt find the Host.CreateDefaultBuilder(args) on program.cs the program.cs has var builder = WebApplication.CreateBuilder(args); that assume has the same functionality, cause the rest works
23

This worked for me .Net 5/6

I have a appsettings.development.json file. I have "Development" environment selected that's why I have settings in my development.json file. You can use appsettings.json with default environment.

enter image description here

with this configuration

enter image description here

created a class with config properties

enter image description here

Registered my calls in Startup

enter image description here

I can now access in my controller

enter image description here

5 Comments

Can we decorate the model property with JsonProperty (Name will be similar to the appsettings one but not the property name) ?
not sure, never tried. you can try and update me.
I tried, no luck in finding the solution. I have modified the appsettings keys itself to align with my project needs
Hey just wanted to say thanks for a well thought out and thorough explanation, this really helped me
This would be better with actual code snippets not images people would have to re-invent code from.
18

The following works for console applications;

  1. Install the following NuGet packages (.csproj);

    <ItemGroup>
        <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.2.0-preview2-35157" />
        <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.2.0-preview2-35157" />
        <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0-preview2-35157" />
    </ItemGroup>
    
  2. Create appsettings.json at root level. Right click on it and "Copy to Output Directory" as "Copy if newer".

  3. Sample configuration file:

    {
      "AppConfig": {
        "FilePath": "C:\\temp\\logs\\output.txt"
      }
    }
    
  4. Program.cs

    configurationSection.Key and configurationSection.Value will have config properties.

    static void Main(string[] args)
    {
        try
        {
    
            IConfigurationBuilder builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
    
            IConfigurationRoot configuration = builder.Build();
            // configurationSection.Key => FilePath
            // configurationSection.Value => C:\\temp\\logs\\output.txt
            IConfigurationSection configurationSection = configuration.GetSection("AppConfig").GetSection("FilePath");
    
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }
    

1 Comment

This would be better with actual code snippets not images people would have to re-invent code from.
15

You can simply use...

var configurations = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();

var db3 = configurations["ConnectionStrings:BookStoresDB2"];

1 Comment

You need to add the following two NuGet packages: Microsoft.Extensions.Configuration Microsoft.Extensions.Configuration.Json
13

Here's the full use-case for ASP.NET Core!

articles.json

{
  "shownArticlesCount": 3,
  "articles": [
    {
      "title": "My Title 1",
      "thumbnailLink": "example.com/img1.png",
      "authorProfileLink": "example.com/@@alper",
      "authorName": "Alper Ebicoglu",
      "publishDate": "2018-04-17",
      "text": "...",
      "link": "..."
    },
    {
      "title": "My Title 2",
      "thumbnailLink": "example.com/img2.png",
      "authorProfileLink": "example.com/@@alper",
      "authorName": "Alper Ebicoglu",
      "publishDate": "2018-04-17",
      "text": "...",
      "link": "..."
    },
  ]
}

ArticleContainer.cs

public class ArticleContainer
{
    public int ShownArticlesCount { get; set; }

    public List<Article> Articles { get; set; }
}

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

    public string ThumbnailLink { get; set; }

    public string AuthorName { get; set; }

    public string AuthorProfileLink { get; set; }

    public DateTime PublishDate { get; set; }

    public string Text { get; set; }

    public string Link { get; set; } 
}

Startup.cs

public class Startup
{
    public IConfigurationRoot ArticleConfiguration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        ArticleConfiguration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("articles.json")
            .Build();
    }

    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddOptions();

        services.Configure<ArticleContainer>(ArticleConfiguration);
    }
}

Index.cshtml.cs

public class IndexModel : PageModel
{
    public ArticleContainer ArticleContainer { get;set; }

    private readonly IOptions<ArticleContainer> _articleContainer;

    public IndexModel(IOptions<ArticleContainer> articleContainer)
    {
        _articleContainer = articleContainer;
    }

    public void OnGet()
    {
        ArticleContainer = _articleContainer.Value;
    }
}

Index.cshtml.cs

<h1>@Model.ArticleContainer.ShownArticlesCount</h1>

3 Comments

"ASP.NET Core" Which version?
@SteveSmith, based on startup constructor this is for ASP.NET Core 2.2. For ASP.NET Core 3.1 just change IHostingEnvironment to IWebHostEnvironment.
@Dush Thanks. One day they'll choose a name and be happy with it.
12
private readonly ILogger<WeatherForecastController> _logger;

private IConfiguration _configuration;

public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
{
    _logger = logger;

    _configuration = configuration;
}

[HttpGet(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
    //You can use any of these

    var db = _configuration.GetSection("ConnectionStrings").GetSection("BookStoresDB2").Value;

    var db1 = _configuration["ConnectionStrings:BookStoresDB2"];

    var db2 = _configuration.GetValue<string>("ConnectionStrings:BookStoresDB2");
}

Comments

11

For .NET Core 2.0, you can simply:

Declare your key/value pairs in appsettings.json:

{
  "MyKey": "MyValue"
}

Inject the configuration service in startup.cs, and get the value using the service

using Microsoft.Extensions.Configuration;

public class Startup
{
    public void Configure(IConfiguration configuration,
                          ... other injected services
                          )
    {
        app.Run(async (context) =>
        {
            string myValue = configuration["MyKey"];
            await context.Response.WriteAsync(myValue);
        });

Comments

10

Super late to the party but if someone finds this out.

You can call IConfiguration from Microsoft.Extensions.Configuration;

public static IConfiguration Configuration { get; }
public static string MyAwesomeString = Configuration.GetSection("appSettings")["MyAwesomeString"].ToString();

Comments

9

Just to complement the Yuval Itzchakov answer.

You can load configuration without builder function, you can just inject it.

public IConfiguration Configuration { get; set; }

public Startup(IConfiguration configuration)
{
   Configuration = configuration;
}

Comments

8

.NET Core 2.1.0

  1. Create the .json file on the root directory
  2. On your code:
var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); 
var config = builder.Build();

3. Install the following dependencies:

Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.json

4. Then, IMPORTANT: Right-click on the appsettings.json file -> click on Properties -> select Copy if newer: enter image description here

  1. Finally, you can do:

    config["key1"]

Considering that my config file will look like this:

{
    "ConnectionStrings": "myconnection string here",
    "key1": "value here"
}

Comments

8

For ASP.NET Core 6.0 you can simply:

appsetting.json

{
  "AppSettings": {
        "Token": "1234"
    }
}

TestModel.cs

using Microsoft.Extensions.Configuration

public class TestModel : PageModel
{
    private readonly IConfiguration Configuration;

    public TestModel(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public ContentResult OnGet()
    {
        var myToken = Configuration["AppSettings:Token"];        
        return Content($"myToken value: {myToken}");
    }
}

1 Comment

Simplest solution so far. Works as expected
7

In addition to existing answers I'd like to mention that sometimes it might be useful to have extension methods for IConfiguration for simplicity's sake.

I keep JWT config in appsettings.json so my extension methods class looks as follows:

public static class ConfigurationExtensions
{
    public static string GetIssuerSigningKey(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:SecurityKey");
        return result;
    }

    public static string GetValidIssuer(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:Issuer");
        return result;
    }

    public static string GetValidAudience(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:Audience");
        return result;
    }

    public static string GetDefaultPolicy(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Policies:Default");
        return result;
    }

    public static SymmetricSecurityKey GetSymmetricSecurityKey(this IConfiguration configuration)
    {
        var issuerSigningKey = configuration.GetIssuerSigningKey();
        var data = Encoding.UTF8.GetBytes(issuerSigningKey);
        var result = new SymmetricSecurityKey(data);
        return result;
    }

    public static string[] GetCorsOrigins(this IConfiguration configuration)
    {
        string[] result =
            configuration.GetValue<string>("App:CorsOrigins")
            .Split(",", StringSplitOptions.RemoveEmptyEntries)
            .ToArray();

        return result;
    }
}

It saves you a lot of lines and you just write clean and minimal code:

...
x.TokenValidationParameters = new TokenValidationParameters()
{
    ValidateIssuerSigningKey = true,
    ValidateLifetime = true,
    IssuerSigningKey = _configuration.GetSymmetricSecurityKey(),
    ValidAudience = _configuration.GetValidAudience(),
    ValidIssuer = _configuration.GetValidIssuer()
};

It's also possible to register IConfiguration instance as singleton and inject it wherever you need - I use Autofac container here's how you do it:

var appConfiguration = AppConfigurations.Get(WebContentDirectoryFinder.CalculateContentRootFolder());
builder.Register(c => appConfiguration).As<IConfigurationRoot>().SingleInstance();

You can do the same with MS Dependency Injection:

services.AddSingleton<IConfigurationRoot>(appConfiguration);

Comments

7

They just keep changing things – having just updated Visual Studio and had the whole project bomb, on the road to recovery and the new way looks like this:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

    if (env.IsDevelopment())
    {
        // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
        builder.AddUserSecrets();
    }

    builder.AddEnvironmentVariables();
    Configuration = builder.Build();
}

I kept missing this line!

.SetBasePath(env.ContentRootPath)

2 Comments

How can we get the AppSettings values in Test Projects using the same approach?
They just keep changing things. This. Almost every answer on this page only applies to a specific version of .Net Core.
5

The .NET Core 2.2 way

(No doubt Microsoft will change it again to something completely different in the next .NET version.)

1. appSettings.json

It may look something like this. Here we will be loading Setting1 and Setting2

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Setting1": "abc",
  "Setting2": 123
}

2. AppSettings.cs

The POCO class to hold Setting1 and Setting2. We will be loading the appsettings.json into this class object. The structure of the POCO class should match the JSON file, properties may be nested within other properties/classes if desired.

public class AppSettings
{
    public string Setting1 { get; set; }
    public int Setting2 { get; set; }
}

3 Startup.cs

Load appSettings.json into you AppSettings object and start using it:

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        AppSettings settings = new AppSettings();

        Configuration = configuration;
        configuration.Bind(settings);

        // Now start using it
        string setting1 = settings.Setting1;
        int setting2 = settings.Setting2;
    }

1 Comment

A combination of new ConfigurationBuilder()...Build() and config.Bind(appSettings) did it for me, thanks
4

Get it inside controller as an object via call Get<YourType>():

public IActionResult Index([FromServices] IConfiguration config)
{
    BillModel model = config.GetSection("Yst.Requisites").Get<BillModel>();
    return View(model);
}

Comments

3

First you should inject IConfiguration and then for reading from appsettings, you can use one of this methods:

  1. Get a section data

    var redisConfig = configuration.GetSection("RedisConfig");
    
  2. Get a value within a section

    var redisServer = configuration.GetValue<string>("RedisConfig:ServerName");
    
  3. Get nested value within section

    var redisExpireMInutes = configuration.GetValue<int>("RedisConfig:ServerName:ExpireMInutes");
    

1 Comment

Injecting works for controllers, but what if I want to use it in Middleware like here? E.G. I am using Redis as middleware to cache http responses.
3

Using .NET 7 with everything in Program.cs

var token = builder.Configuration["AppSettings:token"]

Comments

2

Was this "cheating"? I just made my Configuration in the Startup class static, and then I can access it from anywhere else:

public class Startup
{
    // This method gets called by the runtime. Use this method to add services to the container.
    // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            .AddEnvironmentVariables();

        Configuration = builder.Build();
    }

    public static IConfiguration Configuration { get; set; }

2 Comments

I know this is old, yet people are still reading it. This is not a good practice. This creates a direct reference to a part of your code instead of using DI to load it up, in time when you create a map of your code there will be too many places pointing to your code and you will have to refactor.
Why "a direct reference to my code" is bad? DI is overengeneering a simple task.
2

To get settings data in .Net 6, I use the IConfiguration interface with some abstraction added to help me test it in my projects, making my code more flexible.

For example, there is some API Url in the appsettings.json file:

"ApiBaseUri": "https://dev.api.com/"

To minimize the cost of changing the code due to the fact that the mechanism for working with configs will be changed in the next version of the .Net Core framework, I use a wrapper for the IConfiguration interface.

public interface IConfigurationWrapper
{
    string? GetSectionValue(string key);
}

public class ConfigurationWrapper : IConfigurationWrapper
{
    private readonly IConfiguration _config;

    public ConfigurationWrapper(IConfiguration config)
    {
        _config = config;
    }

    public string? GetSectionValue(string key)
    {
        return _config.GetSection(key).Value;
    }
}

And finally there is a special interface to represent the settings in the config file:

public interface IAppSettings
{
    Uri? GetApiBaseUri();
}

public class AppSettings : IAppSettings
{
    private const string ApiBaseUriSettingName = "ApiBaseUri";

    private readonly IConfigurationWrapper _config;

    public AppSettings(IConfigurationWrapper config)
    {
        _config = config;
    }

    public Uri? GetApiBaseUri()
    {
        string uriValue = _config.GetSectionValue(ApiBaseUriSettingName);

        return string.IsNullOrEmpty(uriValue) ? null : new Uri(uriValue);
    }
}

And that's how I use it in my code:

public class MyService : IMyService
{
    private readonly IAppSettings _settings;

    private readonly IRestRequestFactory _requestFactory;
    private readonly IRestResponseFactory _responseFactory;

    public MyService(IAppSettings settings, IRestRequestFactory requestFactory, IRestResponseFactory responseFactory)
    {
        _settings = settings;
        _requestFactory = requestFactory;
        _responseFactory = responseFactory;
    }

    public async Task<decimal?> GetSomeEndpointResponseAsync(FilterModel filter, CancellationToken token)
    {
        var request = _requestFactory.CreatePostRequest(ApiUrls.SomeEndpoint, filter);

        var response = await _responseFactory.GetRestResponseAsync<ResponseResultModel<decimal?>>(request, _settings.GetApiBaseUri(), token);

        return response.Data?.Data;
    }
}

And I also can easily cover my AppSettings with unit tests:

[TestFixture]
public class AppSettingsTests
{
    private Mock<IConfigurationWrapper> _configurationMock;

    private IAppSettings _settings;

    [SetUp]
    public void SetUp()
    {
        _configurationMock = new Mock<IConfigurationWrapper>();

        _settings = new AppSettings(_configurationMock.Object);
    }

    [Test]
    public void GetApiBaseUri_ApiBaseUriIsEmptyString_ReturnsNull()
    {
        // Arrange
        string uri = string.Empty;

        _configurationMock.Setup(m => m.GetSectionValue(It.IsAny<string>())).Returns(uri);

        // Act
        Uri? result = _settings.GetApiBaseUri();

        // Assert
        Assert.IsNull(result);
    }

    [Test]
    public void GetApiBaseUri_ApiBaseUriIsNull_ReturnsNull()
    {
        // Arrange
        string uri = null;

        _configurationMock.Setup(m => m.GetSectionValue(It.IsAny<string>())).Returns(uri);

        // Act
        Uri? result = _settings.GetApiBaseUri();

        // Assert
        Assert.IsNull(result);
    }
}

Hope this helps.

Comments

0

You can try below code. This is working for me.

public class Settings
{
    private static IHttpContextAccessor _HttpContextAccessor;

    public Settings(IHttpContextAccessor httpContextAccessor)
    {
        _HttpContextAccessor = httpContextAccessor;
    }

    public static void Configure(IHttpContextAccessor httpContextAccessor)
    {
        _HttpContextAccessor = httpContextAccessor;
    }

    public static IConfigurationBuilder Getbuilder()
    {
        var builder = new ConfigurationBuilder()
          .SetBasePath(Directory.GetCurrentDirectory())
          .AddJsonFile("appsettings.json");
        return builder;
    }

    public static string GetAppSetting(string key)
    {
        //return Convert.ToString(ConfigurationManager.AppSettings[key]);
        var builder = Getbuilder();
        var GetAppStringData = builder.Build().GetValue<string>("AppSettings:" + key);
        return GetAppStringData;
    }

    public static string GetConnectionString(string key="DefaultName")
    {
        var builder = Getbuilder();
        var ConnectionString = builder.Build().GetValue<string>("ConnectionStrings:"+key);
        return ConnectionString;
    }
}

Here I have created one class to get connection string and app settings.

I Startup.cs file you need to register class as below.

public class Startup
{

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        var httpContextAccessor = app.ApplicationServices.GetRequiredService<IHttpContextAccessor>();
        Settings.Configure(httpContextAccessor);
    }
}

Comments

0

In addition to Ali's answer, you have to inject the IConfiguration object in constructor:

appsettings.js

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "AppSettings": {
      "ServerUrl": "some url"
  }
  
}

Define AppSettings class

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

Startup.cs

 public class Startup
    {
        private readonly IConfiguration Configuration;
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            ...
        }
    }

Controller

    [Route("api/[controller]")]
    [ApiController]
    public class AuthenticationController : ControllerBase
    {
        private readonly AppSettings config;

        public AuthenticationController (IOptions<AppSettings> config)
        {
            this.config= config.Value;
        }

        [HttpGet("token")]

        public ActionResult Token()
        {
          var server=config.ServerUrl;

        }

Works for .NET 5

Comments

-3

With the latest iteration of netcoreapp 3.1 out, you can do this pretty simply without any third-party dependencies.

I created a gist for this, but you can use this class to read a JSON file and return dynamic properties.

using System.Text.Json;
using System.IO;

class ConfigurationLoader
{

    private dynamic configJsonData;
    public ConfigurationLoader Load(string configFilePath = "appsettings.json")
    {
        var appSettings = File.ReadAllText(configFilePath);
        this.configJsonData = JsonSerializer.Deserialize(appSettings, typeof(object));
        return this;
    }

    public dynamic GetProperty(string key)
    {
        var properties = key.Split(".");
        dynamic property = this.configJsonData;
        foreach (var prop in properties)
        {
            property = property.GetProperty(prop);
        }

        return property;
    }
}

I specifically made this so I could use an appconfig.json in my dotnet console application. I just put this in my Program.Main function:

var config = new ConfigurationLoader();
config.Load();
Console.WriteLine(config.GetProperty("Environment.Name"));

And this will return a dynamic object for the property. (A JsonElement if it's not a primitive). My appsettings.json file looks like this:

{
  "Environment": {
    "Token": "abc-123",
    "Name": "Production"
  }
}

3 Comments

You shouldn't create custom code for something that is built into .NET Core. You're reinventing a worse wheel.
I appreciate your constructive criticism @kellen-stuart . When I had this issue, I was unable to find something built into .NET Core to load appsettings for my console app. Could you point me to the appropriate resource so I can update my solution?
Using the ConfigurationBuilder is the correct way; there's a method called AddJsonFile learn.microsoft.com/en-us/dotnet/api/…

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.