461

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

485

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")); } } 
33
  • 4
    version "1.0.0-beta4" works on mine not "1.0.0-alpha4". Thanks a lot!
    – Oluwafemi
    CommentedJul 16, 2015 at 12:20
  • 8
    After adding the nuget Microsoft.Extensions.Options.ConfigurationExtensions it worked as expected.
    – Peter
    CommentedApr 20, 2018 at 22:19
  • 13
    this code vs old xml > how many of you have time for this, just to save a string?CommentedSep 28, 2018 at 16:00
  • 7
    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.CommentedFeb 12, 2019 at 9:21
  • 81
    Absolutely incredible how convoluted it is just to retrieve an application setting.CommentedMay 24, 2020 at 21:34
180

.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"); 
10
  • 23
    @Essej: You need to install the Microsoft.Extensions.Configuration.Json nuget package in order to use the AddJsonFile methode.
    – Baccata
    CommentedJul 3, 2020 at 11:21
  • 7
    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.
    – MBielski
    CommentedJan 4, 2022 at 22:47
  • 1
    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"]CommentedFeb 22, 2022 at 14:05
  • sidestepping the application host framework is sometimes the best way to go, for some simple console applications for example, thanks for the answer
    – fartwhif
    CommentedMay 12, 2022 at 15:28
  • 5
    Finally a simple solution, thanks. WHY has msft made this so difficult in Core??CommentedJul 10, 2022 at 0:25
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
  • can you please share configuration json for "AppSettings" for referenceCommentedMay 2, 2018 at 13:18
  • 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.CommentedJul 31, 2018 at 1:06
70

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
  • 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
    CommentedMar 12, 2018 at 17:06
  • 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?CommentedMar 12, 2018 at 17:31
  • 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/…
    – Sat Thiru
    CommentedMar 26, 2018 at 4:47
  • 1
    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?
    – Sat Thiru
    CommentedMar 26, 2018 at 5:05
  • 1
    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.
    – Jpsy
    CommentedMay 3, 2018 at 9:21
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
  • 6
    even simpler: var myValue = config["MyKey"]
    – jokab
    CommentedOct 29, 2019 at 0:36
  • 3
    ... 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.CommentedJan 20, 2020 at 4:06
  • and in .net 7 it is working too..
    – ysrtymz
    CommentedMay 28, 2024 at 15:36
44

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

Configuration["AppSettings:token"]

1
  • 10
    For this to work, you need to have an IConfiguration instance initialized via ConfigurationBuilder beforehand.CommentedSep 20, 2019 at 5:11
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
  • 1
    i think this should be fine provided the appsettings.json is in the right directoryCommentedJun 10, 2020 at 22:14
  • 2
    thank you for me : config["AppSettings:JWT_Secret"]
    – Z.W.Huang
    CommentedJul 22, 2021 at 1:36
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
  • 2
    @Ogglas...how the caller of WeatherForecastController() could obtain the class that implements IConfiguration?
    – Johnny Wu
    CommentedJun 21, 2020 at 17:28
  • 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
    – cabaji99
    CommentedAug 29, 2022 at 16:41
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.josn 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

4
  • Can we decorate the model property with JsonProperty (Name will be similar to the appsettings one but not the property name) ?CommentedMay 18, 2021 at 13:00
  • not sure, never tried. you can try and update me.
    – Ali
    CommentedMay 19, 2021 at 10:52
  • 1
    I tried, no luck in finding the solution. I have modified the appsettings keys itself to align with my project needsCommentedMay 24, 2021 at 13:40
  • 1
    Hey just wanted to say thanks for a well thought out and thorough explanation, this really helped me
    – d0rf47
    CommentedMay 13, 2022 at 13:58
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); } } 
    14

    You can simply use...

    var configurations = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); var db3 = configurations["ConnectionStrings:BookStoresDB2"]; 
    1
    • 3
      You need to add the following two NuGet packages: Microsoft.Extensions.Configuration Microsoft.Extensions.Configuration.Json
      – nivs1978
      CommentedApr 24, 2024 at 11:56
    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
    • "ASP.NET Core" Which version?CommentedOct 16, 2019 at 12:43
    • 1
      @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
      CommentedJul 3, 2022 at 1:27
    • @Dush Thanks. One day they'll choose a name and be happy with it.CommentedJul 4, 2022 at 6:38
    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"); } 
      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); }); 
        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(); 
          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; } 
            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" } 
              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
              • 2
                Simplest solution so far. Works as expected
                – tg24
                CommentedDec 7, 2022 at 9:14
              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); 
                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
                • 1
                  How can we get the AppSettings values in Test Projects using the same approach?
                  – S.Siva
                  CommentedSep 30, 2016 at 10:40
                • 3
                  They just keep changing things. This. Almost every answer on this page only applies to a specific version of .Net Core.CommentedOct 16, 2019 at 11:40
                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
                • 1
                  A combination of new ConfigurationBuilder()...Build() and config.Bind(appSettings) did it for me, thanks
                  – Pierre
                  CommentedOct 30, 2020 at 12:14
                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); } 
                  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
                  • 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.CommentedDec 18, 2019 at 19:06
                  3

                  Using .NET 7 with everything in Program.cs

                  var token = builder.Configuration["AppSettings:token"] 
                    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
                    • 2
                      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.
                      – cpoDesign
                      CommentedMay 5, 2021 at 21:28
                    • Why "a direct reference to my code" is bad? DI is overengeneering a simple task.CommentedAug 26, 2021 at 8:40
                    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.

                      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); } } 
                        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

                          -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
                          • 1
                            You shouldn't create custom code for something that is built into .NET Core. You're reinventing a worse wheel.CommentedSep 20, 2021 at 15:21
                          • 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?CommentedSep 21, 2021 at 17:56
                          • 1
                            Using the ConfigurationBuilder is the correct way; there's a method called AddJsonFilelearn.microsoft.com/en-us/dotnet/api/…CommentedSep 22, 2021 at 18:54

                          Start asking to get answers

                          Find the answer to your question by asking.

                          Ask question

                          Explore related questions

                          See similar questions with these tags.