Cómo leer los valores de AppSettings de un archivo .json en ASP.NET Core

He configurado mis datos de AppSettings en el archivo appsettings / Config .json de esta manera:

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

He buscado en línea cómo leer los valores de AppSettings del archivo .json, pero no pude obtener nada útil.

Lo intenté:

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

Sé que con ASP.NET 4.0 puedes hacer esto:

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

Pero, ¿cómo hago esto en ASP.NET Core?

Esto ha tenido algunos giros y vueltas. He modificado esta respuesta para estar al día con ASP.NET Core 2.0 (a partir del 26/02/2018).

Esto se toma principalmente de la documentación oficial :

Para trabajar con la configuración en su aplicación ASP.NET, se recomienda que solo cree una instancia Configurationen la Startupclase de su aplicación . Luego, use el patrón Opciones para acceder a configuraciones individuales. Digamos que tenemos un appsettings.jsonarchivo que se ve así:

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

}

Y tenemos un objeto POCO que representa la configuración:

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

Ahora construimos la configuración en 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();
    }
}

Tenga en cuenta que appsettings.jsonse registrará de forma predeterminada en .NET Core 2.0. También podemos registrar un appsettings.{Environment}.jsonarchivo de configuración por entorno si es necesario.

Si queremos inyectar nuestra configuración a nuestros controladores, necesitaremos registrarla con el tiempo de ejecución. Lo hacemos a través de 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"));
}

Y lo inyectamos así:

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

En primer lugar: el nombre del ensamblado y el espacio de nombres de Microsoft.Framework.ConfigurationModel ha cambiado a Microsoft.Framework.Configuration. Entonces deberías usar: ej.

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

como una dependencia en project.json. Use beta5 o 6 si no tiene 7 instalados. Entonces puedes hacer algo como esto en 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 luego desea recuperar una variable de config.json, puede obtenerla de inmediato 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);
    });
}

o puede crear una clase llamada AppSettings como esta:

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

y configura los servicios de esta manera:

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

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

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

y luego acceda a través de, por ejemplo, un controlador como este:

public class HomeController : Controller
{
    private string _token;

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

Para .NET Core 2.0, las cosas han cambiado un poco. El constructor de inicio toma un objeto de configuración como parámetro, por lo que ConfigurationBuilderno se requiere el uso de. Aquí esta el 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"));
}

Mi POCO es el StorageOptionsobjeto mencionado en la parte superior:

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

Y la configuración es en realidad una subsección de mi appsettings.jsonarchivo, llamada 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"
  }
}

Lo único que voy a añadir es que, dado que el constructor ha cambiado, no he probado si las necesidades adicionales que se haga algo para que se cargue appsettings.<environmentname>.jsonen contraposición a appsettings.json.

Con .NET Core 2.2, y de la manera más simple posible ...

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

appsettings.jsonse carga automáticamente y está disponible mediante el constructor o la inyección de acción, y también hay un GetSectionmétodo IConfigurationactivado. No hay necesidad de alterar Startup.cso Program.cssi todo lo que necesita es appsettings.json.

Si solo desea obtener el valor del token, use

Configuration["AppSettings:token"]

.NET Core 3.0

¡Quizás no sea la mejor manera de obtener un valor de appsettings.json , pero es simple y funciona en mi aplicación!

Archivo appsettings.json

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

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

Controlador:

En la parte superior :

using Microsoft.Extensions.Configuration;

En su código:

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

Lo siguiente funciona para aplicaciones de consola;

1. Instale los siguientes paquetes 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. Crear appsettings.jsona nivel raíz. Haga clic derecho sobre él y "Copiar al directorio de salida" como " Copiar si es más reciente ".

3. Archivo de configuración de muestra:

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

4. Program.cs

   configurationSection.Keyy configurationSection.Valuetendrá propiedades de configuración.

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

Para .NET Core 2.0, puede simplemente:

Declare sus pares clave / valor en appsettings.json:

{
  "MyKey": "MyValue"
}

Inyecte el servicio de configuración en startup.cs y obtenga el valor utilizando el servicio

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

Dudo que sea una buena práctica, pero funciona localmente. Actualizaré esto si falla cuando publico / despliegue (en un servicio web IIS).

Paso 1: agregue este ensamblaje a la parte superior de su clase (en mi caso, clase de controlador):

using Microsoft.Extensions.Configuration;

Paso 2: agrega esto o algo similar:

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

Paso 3: llame al valor de su clave haciendo esto (devuelve una cadena):

config["NameOfYourKey"]

Solo para complementar la respuesta de Yuval Itzchakov.

Puede cargar la configuración sin la función de generador, simplemente puede inyectarla.

public IConfiguration Configuration { get; set; }

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

Además de respuestas existentes que me gustaría mencionar que a veces puede ser útil disponer de métodos de extensión de IConfigurationpor razones de simplicidad.

Mantengo la configuración JWT en appsettings.json para que mi clase de métodos de extensión tenga el siguiente aspecto:

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

Le ahorra muchas líneas y simplemente escribe código limpio y mínimo:

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

También es posible registrar la IConfigurationinstancia como singleton e inyectarla donde lo necesite. Utilizo el contenedor Autofac de la siguiente manera:

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

Puede hacer lo mismo con la inyección de dependencia de MS:

services.AddSingleton<IConfigurationRoot>(appConfiguration);

¡Aquí está el caso de uso completo para ASP.NET Core!

articulos.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>

Siguen cambiando las cosas: acaban de actualizar Visual Studio y de tener todo el proyecto bomba, en camino a la recuperación y la nueva forma se ve así:

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

¡Me faltaba esta línea!

.SetBasePath(env.ContentRootPath)

.NET Core 2.1.0

1. Cree el archivo .json en el directorio raíz
2. En su código:

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

var config = builder.Build();

3. Instale las siguientes dependencias:

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

4. Luego, IMPORTANTE: haga clic derecho en el archivo appsettings.json -> haga clic en Propiedades -> seleccione Copiar si es más reciente:

5. Finalmente, puedes hacer:

   config ["clave1"]

Teniendo en cuenta que mi archivo de configuración se verá así:

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

Puedes probar el siguiente código. Esto es trabajo para mí.

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

Aquí he creado una clase para obtener la cadena de conexión y la configuración de la aplicación.

I Startup.cs necesita registrar la clase como se muestra a continuación.

public class Startup
{

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

Para ASP.NET Core 3.1 puede seguir esta documentación:

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

Cuando cree un nuevo proyecto ASP.NET Core 3.1, tendrá la siguiente línea de configuración en Program.cs:

Host.CreateDefaultBuilder(args)

Esto permite lo siguiente:

1. ChainedConfigurationProvider: Agrega una IConfiguration existente como fuente. En el caso de configuración predeterminada, agrega la configuración del host y la establece como la primera fuente para la configuración de la aplicación.
2. appsettings.json usando el proveedor de configuración JSON.
3. appsettings.Environment.json usando el proveedor de configuración JSON. Por ejemplo, appsettings.Production.json y appsettings.Development.json.
4. Secretos de la aplicación cuando la aplicación se ejecuta en el entorno de Desarrollo.
5. Variables de entorno utilizando el proveedor de configuración de Variables de entorno.
6. Argumentos de la línea de comandos utilizando el proveedor de configuración de la línea de comandos.

Esto significa que puede inyectar IConfigurationy recuperar valores con una clave de cadena, incluso valores anidados. Me gustaIConfiguration ["Parent:Child"];

Ejemplo:

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

¿Fue esto "trampa"? Acabo de hacer mi configuración en la clase de inicio estática, y luego puedo acceder a ella desde cualquier otro lugar:

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

Obténgalo dentro del controlador como un objeto a través de una llamada Get<YourType>():

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

Primero debe inyectar IConfiguration y luego, para leer desde los ajustes de la aplicación, puede usar uno de estos métodos:

1. Obtener una sección de datos

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

2. Obtenga un valor dentro de una sección

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

3. Obtener valor anidado dentro de la sección

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

La forma .NET Core 2.2

(Sin duda, Microsoft lo cambiará nuevamente a algo completamente diferente en la próxima versión de .NET).

1. appSettings.json

Puede parecer algo como esto. Aquí cargaremos Configuración1 y Configuración2

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

2. AppSettings.cs

La clase POCO para mantener la Configuración1 y la Configuración2. Vamos a cargar el appsettings.json en este objeto de clase. La estructura de la clase POCO debe coincidir con el archivo JSON, las propiedades pueden estar anidadas dentro de otras propiedades / clases si se desea.

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

3 Startup.cs

Cargue appSettings.json en su objeto AppSettings y comience 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 la última versión de netcoreapp 3.1, puede hacerlo de manera bastante simple sin dependencias de terceros.

Yo creé una esencia de este , pero se puede utilizar esta clase para leer un archivo JSON y devolver las propiedades dinámicas.

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

Hice esto específicamente para poder usar un appconfig.json en mi aplicación de consola dotnet. Acabo de poner esto en mi Program.Mainfunción:

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

Y esto devolverá un dynamicobjeto para la propiedad. (Un JsonElement si no es un primitivo). Mi appsettings.jsonarchivo se ve así:

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