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

Solución:

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

Esto se toma principalmente de la documentación oficial:

Para trabajar con configuraciones en su aplicación ASP.NET, se recomienda que solo cree una instancia Configuration en tu aplicación Startup clase. Luego, use el patrón de Opciones para acceder a configuraciones individuales. Digamos que tenemos un appsettings.json archivo 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.json estarán registrado por defecto en .NET Core 2.0. También podemos registrar un appsettings.{Environment}.json config archivo 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);
}

El lleno Startup clase:

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: p. Ej.

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

como una dependencia en project.json. Utilice beta5 o 6 si no tiene 7 instalado. 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 configurar los servicios así:

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

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

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

y luego acceda a él 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, así que usando el ConfigurationBuilder no es requerido. 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 StorageOptions objeto 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.json archivo, llamado 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 agregaré es que, dado que el constructor ha cambiado, no he probado si es necesario hacer algo adicional para que se cargue. appsettings.<environmentname>.json Opuesto a appsettings.json.

---

---

Utiliza Nuestro Buscador