Comment lire les valeurs AppSettings à partir d'un fichier .json dans ASP.NET Core

J'ai configuré mes données AppSettings dans le fichier appsettings / Config .json comme ceci:

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

J'ai cherché en ligne sur la façon de lire les valeurs AppSettings du fichier .json, mais je n'ai rien pu trouver d'utile.

J'ai essayé:

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

Je sais qu'avec ASP.NET 4.0, vous pouvez le faire:

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

Mais comment faire cela dans ASP.NET Core?

Cela a eu quelques rebondissements. J'ai modifié cette réponse pour être à jour avec ASP.NET Core 2.0 (au 26/02/2018).

Ceci est principalement tiré de la documentation officielle :

Pour travailler avec les paramètres de votre application ASP.NET, il est recommandé d'instancier uniquement un Configurationdans la Startupclasse de votre application . Ensuite, utilisez le modèle Options pour accéder aux paramètres individuels. Disons que nous avons un appsettings.jsonfichier qui ressemble à ceci:

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

}

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

public class MyConfig
{
    public string 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.jsonsera enregistré par défaut dans .NET Core 2.0. Nous pouvons également enregistrer unappsettings.{Environment}.json fichier de configuration par environnement si nécessaire.

Si nous voulons injecter notre configuration dans nos contrôleurs, nous devons l'enregistrer avec le runtime. Nous le faisons 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"));
}

Et nous l'injectons comme ceci:

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

La Startupclasse 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<T>
        services.AddOptions();

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

Tout d'abord: le nom de l'assembly et l'espace de noms de Microsoft.Framework.ConfigurationModel ont changé pour Microsoft.Framework.Configuration. Vous devez donc utiliser: par exemple

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

comme dépendance dans project.json. Utilisez beta5 ou 6 si vous n'en 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 récupérer une variable à partir du fichier config.json, vous pouvez l'obtenir immédiatement en utilisant:

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

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

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

et configurer les services comme ceci:

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

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

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

puis y accéder par exemple via un contrôleur comme celui-ci:

public class HomeController : Controller
{
    private string _token;

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

Pour .NET Core 2.0, les choses ont un peu changé. Le constructeur de démarrage prend un objet Configuration comme paramètre, il ConfigurationBuildern'est donc pas nécessaire d' utiliser le . 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<StorageOptions>(Configuration.GetSection("AzureStorageConfig"));
}

Mon POCO est l' StorageOptionsobjet mentionné en haut:

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

Et la configuration est en fait une sous-section de mon appsettings.jsonfichier, nommée 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"
  }
}

La seule chose que j'ajouterai est que, puisque le constructeur a changé, je n'ai pas testé si quelque chose de plus doit être fait pour qu'il se charge appsettings.<environmentname>.jsonpar opposition à appsettings.json.

Avec .NET Core 2.2, et de la manière la plus simple possible ...

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

appsettings.jsonest automatiquement chargé et disponible via le constructeur ou l'injection d'action, et il existe également une GetSectionméthode IConfiguration. Il n'est pas nécessaire de modifier Startup.csou Program.cssi tout ce dont vous avez besoin est appsettings.json.

Si vous souhaitez simplement obtenir la valeur du jeton, utilisez

Configuration["AppSettings:token"]

.NET Core 3.0

Ce n'est peut-être pas le meilleur moyen d'obtenir une valeur de appsettings.json , mais c'est simple et cela fonctionne dans mon application !!

Fichier appsettings.json

{
    "ConnectionStrings": {
        "DefaultConnection":****;"
    }

    "AppSettings": {
        "APP_Name": "MT_Service",
        "APP_Version":  "1.0.0"
    }
}

Manette:

En haut :

using Microsoft.Extensions.Configuration;

Dans votre code:

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

Les travaux suivants pour les applications de console;

1. Installez les packages NuGet suivants ( .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. Créez appsettings.jsonau niveau racine. Faites un clic droit dessus et "Copier dans le répertoire de sortie" comme " Copier si plus récent ".

3. Exemple de fichier de configuration:

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

4. Program.cs

   configurationSection.Keyet configurationSection.Valueaura des propriétés de configuration.

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

Pour .NET Core 2.0, vous pouvez simplement:

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

{
  "MyKey": "MyValue"
}

Injectez le service de configuration dans startup.cs et obtenez 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) =>
        {
            string myValue = configuration["MyKey"];
            await context.Response.WriteAsync(myValue);
        });

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

Étape 1 - Ajoutez cet assemblage en haut 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"]

Juste pour compléter la réponse de Yuval Itzchakov.

Vous pouvez charger la configuration sans fonction de générateur, vous pouvez simplement l'injecter.

public IConfiguration Configuration { get; set; }

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

En plus des réponses existantes, je voudrais mentionner que parfois il peut être utile d'avoir des méthodes d'extension pourIConfiguration des raisons de simplicité.

Je garde la configuration JWT dans appsettings.json donc ma classe de méthodes d'extension ressemble à ceci:

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

Cela vous fait économiser beaucoup de lignes et vous écrivez simplement du code propre et minimal:

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

Il est également possible d'enregistrer une IConfigurationinstance en tant que singleton et de l'injecter où vous en avez besoin - J'utilise le conteneur Autofac, voici comment vous le faites:

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

Vous pouvez faire de même avec MS Dependency Injection:

services.AddSingleton<IConfigurationRoot>(appConfiguration);

Voici le cas d'utilisation complet pour 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>

Ils ne cessent de changer les choses - après avoir mis à jour Visual Studio et avoir toute la bombe du projet, sur la voie de la récupération et la nouvelle façon de procéder 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)

.NET Core 2.1.0

1. Créez le fichier .json dans le répertoire racine
2. Sur votre code:

var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); 

var config = builder.Build();

3. Installez les dépendances suivantes:

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

4. Ensuite, IMPORTANT: Faites un clic droit sur le fichier appsettings.json -> cliquez sur Propriétés -> sélectionnez Copier si plus récent:

5. Enfin, vous pouvez faire:

   config ["key1"]

Étant donné que mon fichier de configuration ressemblera à ceci:

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

Vous pouvez essayer le code ci-dessous. Cela fonctionne pour moi.

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

Ici, j'ai créé une classe pour obtenir la chaîne de connexion et les paramètres de l'application.

I Fichier Startup.cs dont vous avez besoin pour enregistrer la classe comme ci-dessous.

public class Startup
{

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

Pour ASP.NET Core 3.1, vous pouvez suivre cette documentation:

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

Lorsque vous créez un nouveau projet ASP.NET Core 3.1, vous aurez la ligne de configuration suivante dans Program.cs:

Host.CreateDefaultBuilder(args)

Cela permet les opérations suivantes:

1. ChainedConfigurationProvider: ajoute une IConfiguration existante en tant que source. Dans le cas de la configuration par défaut, ajoute la configuration d'hôte et la définit comme première source pour la configuration de l'application.
2. appsettings.json à l'aide du fournisseur de configuration JSON.
3. appsettings.Environment.json à l'aide du fournisseur de configuration JSON. Par exemple, appsettings.Production.json et appsettings.Development.json.
4. Secrets d'application lorsque l'application s'exécute dans l'environnement de développement.
5. Variables d'environnement à l'aide du fournisseur de configuration Variables d'environnement.
6. Arguments de ligne de commande à l'aide du fournisseur de configuration de ligne de commande.

Cela signifie que vous pouvez injecter IConfigurationet récupérer des valeurs avec une clé de chaîne, même des valeurs imbriquées. CommeIConfiguration ["Parent:Child"];

Exemple:

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

Était-ce "tricher"? Je viens de rendre ma configuration dans la classe de démarrage statique, puis je peux y accéder depuis n'importe où ailleurs:

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

Obtenez-le dans le contrôleur en tant qu'objet via un appel Get<YourType>():

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

Vous devez d'abord injecter IConfiguration, puis pour lire à partir des paramètres des applications, vous pouvez utiliser l'une des méthodes suivantes:

1. Obtenez les données d'une section

   var redisConfig = configuration.GetSection("RedisConfig");

2. Obtenez une valeur dans une section

   var redisServer = configuration.GetValue<string>("RedisConfig:ServerName");

3. Obtenez la valeur imbriquée dans la section

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

La manière .NET Core 2.2

(Nul doute que Microsoft le changera à nouveau en quelque chose de complètement différent dans la prochaine version .NET.)

1. appSettings.json

Cela peut ressembler à ceci. Ici, nous allons charger Setting1 et Setting2

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

2. AppSettings.cs

La POCO classe pour tenir Setting1 et Setting2. Nous allons charger le appsettings.json dans cet objet de classe. La structure de la classe POCO doit correspondre au fichier JSON, les propriétés peuvent être imbriquées dans d'autres propriétés / classes si vous le souhaitez.

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

3 Startup.cs

Chargez appSettings.json dans votre objet AppSettings et commencez à l'utiliser:

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

Avec la dernière itération de netcoreapp 3.1, vous pouvez le faire assez simplement sans aucune dépendance tierce.

J'ai créé un résumé pour cela , mais vous pouvez utiliser cette classe pour lire un fichier JSON et retourner des propriétés dynamiques.

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

J'ai fait cela spécifiquement pour pouvoir utiliser un appconfig.json dans mon application de console dotnet. Je viens de mettre cela dans ma Program.Mainfonction:

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

Et cela retournera un dynamicobjet pour la propriété. (Un JsonElement si ce n'est pas une primitive). Mon appsettings.jsonfichier ressemble à ceci:

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