c# - iconfiguration - Cómo leer los valores de AppSettings del archivo.json en ASP.NET Core

net core web config

Question

He configurado mis datos de AppSettings en 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?

Answer 1

¡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>

Answer 2

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

Answer 3

Además de las respuestas existentes, me gustaría mencionar que a veces puede ser útil tener métodos de extensión para IConfiguration por 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 instancia de IConfiguration 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);

Answer 4

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

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

appsettings.json se carga automáticamente y está disponible a través del constructor o la inyección de acción, y también hay un método GetSection en IConfiguration . No es necesario modificar Startup.cs o Program.cs si todo lo que necesita es appsettings.json .

Answer 5

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"]

Answer 6

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

Answer 7

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 de Configuration en la clase de Startup su aplicación. Luego, use el patrón Opciones para acceder a configuraciones individuales. Digamos que tenemos un archivo appsettings.json 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 se registrará de forma predeterminada en .NET Core 2.0. También podemos registrar una appsettings.{Environment}.json archivo 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 clase de Startup 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"));
    }
}

Answer 8

Los siguientes trabajos para las aplicaciones de consola;

1- instala los siguientes paquetes .csproj ( .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.json a 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.Key y configurationSection.Value tendrán 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);
    }
}

Answer 9

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 no es necesario usar ConfigurationBuilder . 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 objeto StorageOptions mencionado en la parte superior:

namespace Brazzers.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 archivo appsettings.json , llamado AzureStorageConfig :

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)//mssqllocaldb;",
    "StorageConnectionString": "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",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=brazzerswebapp;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 cargar los appsettings.<environmentname>.json en lugar de appsettings.json .

Answer 10

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

Answer 11

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

Answer 12

Si solo desea obtener el valor del token, use

Configuration["AppSettings:token"]

Answer 13

Siguen cambiando las cosas: acaban de actualizar VS 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)

Answer 14

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

Answer 15

Get<YourType>() dentro del controlador como objeto mediante la llamada Get<YourType>()

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