Comment lire les valeurs AppSettings de Config.json dans ASP.NET Core

J’ai ma configuration AppSettings dans Config.json comme ceci:

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

J’ai cherché en ligne sur la façon de lire les valeurs AppSettings de config.json mais je ne pouvais rien obtenir d’utile.

J’ai essayé:

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

Je sais avec ASP.NET 4.0 que vous pouvez faire ceci:

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

Mais comment puis-je faire cela dans ASP.NET Core?

Cela a eu quelques rebondissements. J’ai modifié cette réponse pour la mettre à jour avec ASP.NET Core 2.0 (à partir du 26/02/2018).

Cela provient principalement de la documentation officielle :

Pour utiliser les parameters de votre application ASP.NET, il est recommandé d’instancier uniquement une Configuration dans la classe de Startup votre application. Ensuite, utilisez le modèle Options pour accéder aux parameters individuels. Disons que nous avons un fichier appsettings.json qui ressemble à ceci:

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

Et nous avons un object POCO représentant la configuration:

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

Maintenant, nous construisons la configuration dans 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(); } } 

Notez que appsettings.json sera enregistré par défaut dans .NET Core 2.0. Si nécessaire, nous pouvons également enregistrer un fichier de configuration appsettings.{Environment}.json par environnement.

Si nous voulons injecter notre configuration dans nos contrôleurs, nous devons l’enregistrer avec le moteur d’exécution. Nous le faisons via Startup.ConfigureServices :

 public void ConfigureServices(IServiceCollection services) { services.AddMvc(); // Add functionality to inject IOptions services.AddOptions(); // Add our Config object so it can be injected services.Configure(Configuration.GetSection("MyConfig")); } 

Et nous l’injectons comme ceci:

 public class HomeController : Controller { private readonly IOptions config; public HomeController(IOptions config) { this.config = config; } // GET: // public IActionResult Index() => View(config.Value); } 

La classe de Startup complète:

 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 services.AddOptions(); // Add our Config object so it can be injected services.Configure(Configuration.GetSection("MyConfig")); } } 

Tout d’abord: le nom de l’assembly et l’espace de noms de Microsoft.Framework.ConfigurationModel ont été remplacés par Microsoft.Framework.Configuration. Donc, vous devriez utiliser: par exemple

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

en tant que dépendance dans project.json . Utilisez beta5 ou 6 si vous n’avez pas 7 installé. Ensuite, vous pouvez faire quelque chose comme ça dans 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(); } 

Si vous souhaitez ensuite extraire une variable du fichier config.json, vous pouvez l’obtenir immédiatement en utilisant:

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

ou vous pouvez créer une classe appelée AppSettings comme ceci:

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

et configurez les services comme ceci:

 public void ConfigureServices(IServiceCollection services) { services.AddMvc(); services.Configure(options => { //mvc options }); services.Configure(Configuration.GetSection("AppSettings")); } 

et ensuite y accéder via un contrôleur comme celui-ci:

 public class HomeController : Controller { private ssortingng _token; public HomeController(IOptions settings) { _token = settings.Options.token; } } 

Pour .NET Core 2.0, les choses ont un peu changé. Le constructeur de démarrage prend un object Configuration en tant que paramètre. Il n’est donc pas nécessaire d’utiliser ConfigurationBuilder . Voici le mien:

 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(Configuration.GetSection("AzureStorageConfig")); } 

Mon POCO est l’object StorageOptions mentionné en haut:

 namespace Brazzers.Models { public class StorageOptions { public Ssortingng StorageConnectionSsortingng { get; set; } public Ssortingng AccountName { get; set; } public Ssortingng AccountKey { get; set; } public Ssortingng DefaultEndpointsProtocol { get; set; } public Ssortingng EndpointSuffix { get; set; } public StorageOptions() { } } } 

Et la configuration est en fait une sous-section de mon fichier appsettings.json , nommé AzureStorageConfig :

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

La seule chose que j’appendai est que, depuis que le constructeur a changé, je n’ai pas testé si quelque chose de plus doit être fait pour charger les appsettings..json par opposition à appsettings.json .

Si vous voulez juste obtenir la valeur du jeton, utilisez

Configuration["AppSettings:token"]

Ils ne cessent de changer les choses – ils viennent de mettre à jour VS et ont eu toute la bombe du projet, sur la voie de la récupération et la nouvelle manière ressemble à ceci:

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

J’ai toujours manqué cette ligne!

 .SetBasePath(env.ContentRootPath) 

Je doute donc que ce soit une bonne pratique mais que cela fonctionne localement, je le mettrai à jour s’il échoue lorsque je publie / déploie (sur un service Web IIS).

Étape 1.) Ajoutez cet assemblage au sumt de votre classe (dans mon cas, classe de contrôleur):

using Microsoft.Extensions.Configuration;

Étape 2.) Ajoutez ceci ou quelque chose comme ça:

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

Étape 3.) Appelez la valeur de votre clé en faisant ceci (retourne une chaîne):

config["NameOfYourKey"]

Pour compléter la réponse de Yuval Itzchakov.

Vous pouvez charger la configuration sans fonction constructeur, vous pouvez simplement l’injecter.

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

Pour .NET Core 2.0, vous pouvez simplement:

Déclarez vos paires clé / valeur dans appsettings.json:

 { "MyKey": "MyValue } 

Injecter le service de configuration dans startup.cs et obtenir la valeur à l’aide du service

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

Était-ce “sortingcher”? Je viens de rendre ma configuration statique dans la classe de démarrage, puis je peux y accéder depuis n’importe où:

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

Merci @Brian Moore

En changeant la configuration en statique dans Startup.cs, je peux encore accéder à ma chaîne de connexion avec une seule ligne de code:

Mon fichier appsettings.json:

  "MyConnectionSsortingngs": { "Connection1": "ConnectionSsortingng..." } }