Come leggere i valori di AppSettings da un file .json in ASP.NET Core

Ho impostato i miei dati AppSettings in file appsettings / Config .json in questo modo:

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

Ho cercato online su come leggere i valori di AppSettings dal file .json, ma non sono riuscito a ottenere nulla di utile.

Provai:

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

So che con ASP.NET 4.0 puoi farlo:

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

Ma come posso farlo in ASP.NET Core?

Ciò ha avuto alcuni colpi di scena. Ho modificato questa risposta per essere aggiornato con ASP.NET Core 2.0 (al 26/02/2018).

Questo è per lo più preso dalla documentazione ufficiale :

Per utilizzare le impostazioni nell'applicazione ASP.NET, si consiglia di creare un'istanza solo Configurationnella Startupclasse dell'applicazione . Quindi, utilizzare il modello Opzioni per accedere alle singole impostazioni. Supponiamo di avere un appsettings.jsonfile simile al seguente:

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

}

E abbiamo un oggetto POCO che rappresenta la configurazione:

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

Ora costruiamo la configurazione 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();
    }
}

Si noti che appsettings.jsonverrà registrato per impostazione predefinita in .NET Core 2.0. Se necessario, possiamo anche registrare un appsettings.{Environment}.jsonfile di configurazione per ambiente.

Se vogliamo iniettare la nostra configurazione nei nostri controller, dovremo registrarla con il runtime. Lo facciamo tramite 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"));
}

E lo iniettiamo in questo modo:

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 completa :

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

Prima di tutto: il nome dell'assembly e lo spazio dei nomi di Microsoft.Framework.ConfigurationModel sono stati modificati in Microsoft.Framework.Configuration. Quindi dovresti usare: es

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

come dipendenza in project.json. Usa beta5 o 6 se non ne hai 7 installati. Quindi puoi fare qualcosa del genere 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();
}

Se vuoi quindi recuperare una variabile da config.json puoi ottenerla immediatamente usando:

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

oppure puoi creare una classe chiamata AppSettings come questa:

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

e configurare i servizi in questo modo:

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

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

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

e quindi accedervi tramite ad esempio un controller come questo:

public class HomeController : Controller
{
    private string _token;

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

Per .NET Core 2.0, le cose sono cambiate un po '. Il costruttore di avvio accetta un oggetto Configuration come parametro, pertanto ConfigurationBuildernon è necessario l'utilizzo di. Ecco il mio:

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

Il mio POCO è l' StorageOptionsoggetto menzionato in alto:

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

E la configurazione è in realtà una sottosezione del mio appsettings.jsonfile, denominata 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"
  }
}

L'unica cosa che aggiungerò è che, dal momento che il costruttore è cambiato, non ho verificato se è necessario fare qualcosa in più per caricarlo appsettings.<environmentname>.jsonal contrario appsettings.json.

Con .NET Core 2.2 e nel modo più semplice possibile ...

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

appsettings.jsonviene automaticamente caricato e disponibile tramite il costruttore o l'azione di iniezione, e c'è anche un GetSectionmetodo IConfiguration. Non è necessario modificare Startup.cso Program.csse tutto ciò che serve è appsettings.json.

Se vuoi solo ottenere il valore del token, usa

Configuration["AppSettings:token"]

.NET Core 3.0

Forse non è il modo migliore per ottenere un valore da appsettings.json , ma è semplice e funziona nella mia applicazione !!

File appsettings.json

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

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

controller:

In cima :

using Microsoft.Extensions.Configuration;

Nel tuo codice:

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

Quanto segue funziona per le applicazioni console;

1. Installa i seguenti pacchetti NuGet ( .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. Crea appsettings.jsona livello di root. Fare clic destro su di esso e "Copia nella directory di output" come " Copia se più recente ".

3. File di configurazione di esempio:

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

4. Program.cs

   configurationSection.Keye configurationSection.Valueavrà proprietà di configurazione.

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

Per .NET Core 2.0, puoi semplicemente:

Dichiarare le coppie chiave / valore in appsettings.json:

{
  "MyKey": "MyValue"
}

Iniettare il servizio di configurazione in startup.cs e ottenere il valore utilizzando il servizio

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

Dubito che questa sia una buona pratica ma funziona localmente. Lo aggiornerò se fallisce quando pubblico / distribuisco (a un servizio Web IIS).

Passaggio 1: aggiungi questo assembly all'inizio della tua classe (nel mio caso, classe controller):

using Microsoft.Extensions.Configuration;

Passaggio 2: aggiungi questo o qualcosa del genere:

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

Passaggio 3: chiama il valore della tua chiave in questo modo (restituisce una stringa):

config["NameOfYourKey"]

Solo per integrare la risposta Yuval Itzchakov.

Puoi caricare la configurazione senza la funzione builder, puoi semplicemente iniettarla.

public IConfiguration Configuration { get; set; }

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

Oltre alle risposte esistenti, vorrei ricordare che a volte potrebbe essere utile disporre di metodi di estensione perIConfiguration motivi di semplicità.

Continuo a configurare JWT in appsettings.json in modo che la mia classe dei metodi di estensione sia la seguente:

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

Ti fa risparmiare molte righe e scrivi solo codice pulito e minimale:

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

È anche possibile registrare l' IConfigurationistanza come singleton e iniettarla dove serve - Uso il contenitore Autofac ecco come lo fai:

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

Puoi fare lo stesso con MS Dependency Injection:

services.AddSingleton<IConfigurationRoot>(appConfiguration);

Ecco il caso d'uso completo per 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>

Continuano a cambiare le cose: dopo aver appena aggiornato Visual Studio e aver avuto l'intera bomba del progetto, sulla strada del recupero e il nuovo modo è simile al seguente:

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

Ho perso questa linea!

.SetBasePath(env.ContentRootPath)

.NET Core 2.1.0

1. Creare il file .json nella directory principale
2. Sul tuo codice:

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

var config = builder.Build();

3. Installare le seguenti dipendenze:

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

4. Quindi, IMPORTANTE: fare clic con il tasto destro del mouse sul file appsettings.json -> fare clic su Proprietà -> selezionare Copia se più recente:

5. Finalmente puoi fare:

   config [ "key1"]

Considerando che il mio file di configurazione sarà simile al seguente:

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

Puoi provare sotto il codice. Questo funziona per 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;
    }
}

Qui ho creato una classe per ottenere la stringa di connessione e le impostazioni dell'app.

I file Startup.cs è necessario registrare la classe come di seguito.

public class Startup
{

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

Per ASP.NET Core 3.1 puoi seguire questa documentazione:

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

Quando si crea un nuovo progetto ASP.NET Core 3.1, si avrà la seguente riga di configurazione in Program.cs:

Host.CreateDefaultBuilder(args)

Ciò consente quanto segue:

1. ChainedConfigurationProvider: aggiunge una configurazione esistente come sorgente. Nel caso della configurazione predefinita, aggiunge la configurazione dell'host e la imposta come prima fonte per la configurazione dell'app.
2. appsettings.json utilizzando il provider di configurazione JSON.
3. appsettings.Environment.json utilizzando il provider di configurazione JSON. Ad esempio, appsettings.Production.json e appsettings.Development.json.
4. Segreti dell'app quando l'app viene eseguita nell'ambiente di sviluppo.
5. Variabili d'ambiente usando il provider di configurazione Variabili d'ambiente.
6. Argomenti della riga di comando utilizzando il provider di configurazione della riga di comando.

Ciò significa che è possibile iniettare IConfiguratione recuperare valori con una chiave stringa, anche valori nidificati. PiaceIConfiguration ["Parent:Child"];

Esempio:

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

Questo è stato "barare"? Ho appena reso statica la mia configurazione nella classe Startup e quindi posso accedervi da qualsiasi altra parte:

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

Ricevilo all'interno del controller come oggetto tramite chiamata Get<YourType>():

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

Innanzitutto è necessario iniettare IConfiguration e quindi per leggere dalle impostazioni delle app, è possibile utilizzare uno di questi metodi:

1. Ottieni una sezione di dati

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

2. Ottieni un valore all'interno di una sezione

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

3. Ottieni valore nidificato all'interno della sezione

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

Il modo .NET Core 2.2

(Senza dubbio Microsoft lo cambierà di nuovo in qualcosa di completamente diverso nella prossima versione di .NET.)

1. appSettings.json

Potrebbe assomigliare a questo. Qui caricheremo Setting1 e Setting2

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

2. AppSettings.cs

La classe POCO per contenere Setting1 e Setting2. Caricheremo appsettings.json in questo oggetto di classe. La struttura della classe POCO deve corrispondere al file JSON, se lo si desidera è possibile nidificare le proprietà all'interno di altre proprietà / classi.

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

3 Startup.cs

Carica appSettings.json nell'oggetto AppSettings e inizia a usarlo:

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

Con l'ultima versione di netcoreapp 3.1 disponibile, puoi farlo in modo abbastanza semplice senza dipendenze di terze parti.

Ho creato un'idea per questo , ma è possibile utilizzare questa classe per leggere un file JSON e restituire proprietà dinamiche.

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

Ho fatto questo in modo specifico per poter utilizzare un appconfig.json nella mia applicazione console dotnet. Ho appena messo questo nella mia Program.Mainfunzione:

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

E questo restituirà un dynamicoggetto per la proprietà. (Un JsonElement se non è un primitivo). Il mio appsettings.jsonfile è simile al seguente:

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