Problem
I’m not sure what I’m missing, but I can’t seem to get the values from my appsettings.json into my.net core app. My appsettings.json is as follows:
{
"AppSettings": {
"Version": "One"
}
}
Startup:
public class Startup
{
private IConfigurationRoot _configuration;
public Startup(IHostingEnvironment env)
{
_configuration = new ConfigurationBuilder()
}
public void ConfigureServices(IServiceCollection services)
{
//Here I setup to read appsettings
services.Configure<AppSettings>(_configuration.GetSection("AppSettings"));
}
}
Model:
public class AppSettings
{
public string Version{ get; set; }
}
Controller:
public class HomeController : Controller
{
private readonly AppSettings _mySettings;
public HomeController(IOptions<AppSettings> settings)
{
//This is always null
_mySettings = settings.Value;
}
}
The variable _mySettings is always null. Is there something I’m overlooking here?
Asked by aman
Solution #1
In the Startup function Object() { [native code] }, you don’t need to create a new IConfiguration. The DI system will inject it with its implementation.
// Program.cs
public class Program
{
public static void Main(string[] args)
{
BuildWebHost(args).Run();
}
public static IWebHost BuildWebHost(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
// Startup.cs
public class Startup
{
public IHostingEnvironment HostingEnvironment { get; private set; }
public IConfiguration Configuration { get; private set; }
public Startup(IConfiguration configuration, IHostingEnvironment env)
{
this.HostingEnvironment = env;
this.Configuration = configuration;
}
}
To load the appsettings files, you must inform Startup to do so.
// Program.cs
public class Program
{
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
.UseApplicationInsights()
.Build();
host.Run();
}
}
//Startup.cs
public class Startup
{
public IConfigurationRoot Configuration { get; private set; }
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
this.Configuration = builder.Build();
}
...
}
You can get the value you specify in the app settings in a variety of ways:
Take, for example, your appsettings. This is how json looks:
{
"ConnectionStrings": {
...
},
"AppIdentitySettings": {
"User": {
"RequireUniqueEmail": true
},
"Password": {
"RequiredLength": 6,
"RequireLowercase": true,
"RequireUppercase": true,
"RequireDigit": true,
"RequireNonAlphanumeric": true
},
"Lockout": {
"AllowedForNewUsers": true,
"DefaultLockoutTimeSpanInMins": 30,
"MaxFailedAccessAttempts": 5
}
},
"Recaptcha": {
...
},
...
}
You can inject the entire configuration (through IConfiguration) into the constructor of your controller/class and get the value you want with a defined key:
public class AccountController : Controller
{
private readonly IConfiguration _config;
public AccountController(IConfiguration config)
{
_config = config;
}
[AllowAnonymous]
public IActionResult ResetPassword(int userId, string code)
{
var vm = new ResetPasswordViewModel
{
PasswordRequiredLength = _config.GetValue<int>(
"AppIdentitySettings:Password:RequiredLength"),
RequireUppercase = _config.GetValue<bool>(
"AppIdentitySettings:Password:RequireUppercase")
};
return View(vm);
}
}
The ConfigurationBuilder is a tool for creating configurations. If you only require one or two values from the app settings, GetValueT> is a perfect option. However, if you need many values from the app settings and don’t want to hard code those key strings in multiple locations, Options Pattern might be a better option. The hierarchy/structure is represented by classes in the choices pattern.
To make use of the pattern options:
You can create classes with properties that must match the keys in your app’s settings exactly. The class name does not have to match the section name in the app settings:
public class AppIdentitySettings
{
public UserSettings User { get; set; }
public PasswordSettings Password { get; set; }
public LockoutSettings Lockout { get; set; }
}
public class UserSettings
{
public bool RequireUniqueEmail { get; set; }
}
public class PasswordSettings
{
public int RequiredLength { get; set; }
public bool RequireLowercase { get; set; }
public bool RequireUppercase { get; set; }
public bool RequireDigit { get; set; }
public bool RequireNonAlphanumeric { get; set; }
}
public class LockoutSettings
{
public bool AllowedForNewUsers { get; set; }
public int DefaultLockoutTimeSpanInMins { get; set; }
public int MaxFailedAccessAttempts { get; set; }
}
Then, during startup, you must register this configuration instance in ConfigureServices():
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
...
namespace DL.SO.UI.Web
{
public class Startup
{
...
public void ConfigureServices(IServiceCollection services)
{
...
var identitySettingsSection =
_configuration.GetSection("AppIdentitySettings");
services.Configure<AppIdentitySettings>(identitySettingsSection);
...
}
...
}
}
Finally, on the controller/class where you want the data, use the constructor to inject IOptionsAppIdentitySettings>:
public class AccountController : Controller
{
private readonly AppIdentitySettings _appIdentitySettings;
public AccountController(IOptions<AppIdentitySettings> appIdentitySettingsAccessor)
{
_appIdentitySettings = appIdentitySettingsAccessor.Value;
}
[AllowAnonymous]
public IActionResult ResetPassword(int userId, string code)
{
var vm = new ResetPasswordViewModel
{
PasswordRequiredLength = _appIdentitySettings.Password.RequiredLength,
RequireUppercase = _appIdentitySettings.Password.RequireUppercase
};
return View(vm);
}
}
Answered by David Liang
Solution #2
Simply create an AnyName.cs file and paste the code below.
using System;
using System.IO;
using Microsoft.Extensions.Configuration;
namespace Custom
{
static class ConfigurationManager
{
public static IConfiguration AppSetting { get; }
static ConfigurationManager()
{
AppSetting = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("YouAppSettingFile.json")
.Build();
}
}
}
You must replace the name of the file YouAppSettingFile.json with the name of your file. The following is what your.json file should look like.
{
"GrandParent_Key" : {
"Parent_Key" : {
"Child_Key" : "value1"
}
},
"Parent_Key" : {
"Child_Key" : "value2"
},
"Child_Key" : "value3"
}
You can now utilize it. Remember to provide a reference in your class where you wish to use it.
using Custom;
Value retrieval code.
string value1 = ConfigurationManager.AppSetting["GrandParent_Key:Parent_Key:Child_Key"];
string value2 = ConfigurationManager.AppSetting["Parent_Key:Child_Key"];
string value3 = ConfigurationManager.AppSetting["Child_Key"];
Answered by shajji
Solution #3
Adding to David Liang’s Core 2.0 response –
The ASPNETCORE ENVIRONMENT variable is related to the appsettings.json files.
ASPNETCORE_ENVIRONMENT can be set to any value, but three values are supported by the framework: Development, Staging, and Production. It will default to Production if ASPNETCORE ENVIRONMENT is not defined.
For these three values these appsettings.ASPNETCORE_ENVIRONMENT.json files are supported out of the box – appsettings.Staging.json, appsettings.Development.json and appsettings.Production.json
The three json files listed above can be used to configure numerous environments.
Example – appsettings.Staging.json
{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"System": "Information",
"Microsoft": "Information"
}
},
"MyConfig": "My Config Value for staging."
}
To get any configuration value, use Configuration[“config var”].
public class Startup
{
public Startup(IHostingEnvironment env, IConfiguration config)
{
Environment = env;
Configuration = config;
var myconfig = Configuration["MyConfig"];
}
public IConfiguration Configuration { get; }
public IHostingEnvironment Environment { get; }
}
Answered by Aseem Gautam
Solution #4
I suppose the simplest method is to use DI. This is an example of using Controller.
// StartUp.cs
public void ConfigureServices(IServiceCollection services)
{
...
// for get appsettings from anywhere
services.AddSingleton(Configuration);
}
public class ContactUsController : Controller
{
readonly IConfiguration _configuration;
public ContactUsController(
IConfiguration configuration)
{
_configuration = configuration;
// sample:
var apiKey = _configuration.GetValue<string>("SendGrid:CAAO");
...
}
}
Answered by Sith2021
Solution #5
Using the injected IConfiguration object, you may access appsettings.json and many other settings in the Startup class’s constructor:
Startup.cs Constructor
public Startup(IConfiguration configuration)
{
Configuration = configuration;
//here you go
var myvalue = Configuration["Grandfather:Father:Child"];
}
public IConfiguration Configuration { get; }
Contents of appsettings.json
{
"Grandfather": {
"Father": {
"Child": "myvalue"
}
}
Answered by Shadi Namrouti
Post is based on https://stackoverflow.com/questions/46940710/getting-value-from-appsettings-json-in-net-core