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

247

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?

Oluwafemi
fuente
esto puede incluso simplificarse simplemente usando la inyección de dependencia de IConfiguration (en .net core 2.0). Lo que se explica aquí coding-issues.com/2018/10/…
Ranadheer Reddy
@RanadheerReddy, la inyección de dependencia funciona para los controladores. Pero, ¿qué pasa si alguien necesita leer un valor en Middleware?
Alexander Ryan Baggett

Respuestas:

319

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"));
    }
}
Yuval Itzchakov
fuente
3
La versión no "1.0.0-beta4"funciona en la mía "1.0.0-alpha4". ¡Muchas gracias!
Oluwafemi
2
Necesito pasar una configuración a otra capa desde una clase de utilidad, así que necesito algo como esta cadena estática pública GetConnectionString () {if (string.IsNullOrEmpty (connectionString)) {var builder = new ConfigurationBuilder () .AddJsonFile ("config.json "); Configuration = builder.Build (); connectionString = Configuration.Get ("Datos: DefaultConnection: ConnectionString"); }} return connectionString; }
dnxit
2
ObtengoArgument 2: cannot convert from 'Microsoft.Extensions.Configuration.IConfigurationSection' to 'System.Action<....Settings>'
Peter
55
Después de agregar el nuget Microsoft.Extensions.Options.ConfigurationExtensionsfuncionó como se esperaba.
Peter
2
Buena explicación de la lógica del proceso de configuración, pero se pierde un punto importante: SetBasePath () y AddJsonFile () son métodos de extensión, que se encuentran profundamente en el marco en ensamblajes separados. Entonces, para comenzar, uno necesita instalar Microsoft.Extensions.Configuration.FileExtensions y Microsoft.Extensions.Configuration.Json además de Microsoft.Extensions.Configuration.
Bozhidar Stoyneff
63

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;
    }
}
abrazo
fuente
¿podría compartir la configuración json para "AppSettings" como referencia?
Ankit Mori
Necesito configuraciones completas de appSettings.json en clase, para esto, he diseñado la clase según JSON y la uso Configuration.Get<AppSettings>()para deserializar todo el archivo en lugar de una sección específica.
Nilay
52

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.

MDMoore313
fuente
Solo una nota de que todavía necesita lanzar .AddJsonFile ("yourfile.json") a ConfigConfiguration. IE, necesita decirle dónde está el archivo. No vi eso en la respuesta.
Eric
Eric, volveré a probar eso, no recuerdo haber agregado esa línea; ¿Podría ser necesario solo si el nombre del archivo json no es el nombre predeterminado?
MDMoore313
Según MSDN, no es necesario para ASPNETCORE 2.0, aunque tampoco parece funcionar para mí. docs.microsoft.com/en-us/dotnet/api/…
Sáb Thiru
1
Puedo confirmar que tuve que construir un objeto ConfigurationBuilder () y llamar a AddJSONFile () para cargar los archivos appSettings.json en el diccionario de configuración. Este es ASP.NET Core 2.0. ¿Es esto un error ya que es contrario a lo que dice MSDN?
Sáb Thiru
1
¿Puede dar un ejemplo de cómo inyecta StorageOptions en sus controladores? Si uso el enfoque de hug de usar la inyección de dependencia con public HomeController(IOptions<StorageOptions> settings), recibo este mensaje de error: Los tipos complejos vinculados al modelo no deben ser abstractos o de valor y deben tener un constructor sin parámetros.
Jpsy
30

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.

tnJed
fuente
2
aún más simple:var myValue = config["MyKey"]
jokab
... y puede hacer: config ["Storage: ConnectionString"] para obtener elementos dentro del json. Puedo confirmar que esta técnica funciona en .net core 3 y funciona en la inyección de construcción.
Mário Meyrelles
29

Si solo desea obtener el valor del token, use

Configuration["AppSettings:token"]

kodebot
fuente
44
Para que esto funcione, debe tener una instancia de IConfiguration inicializada a través de ConfigurationBuilder de antemano.
Ε Г И І И О
20

.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"];
Alexander S.
fuente
Muy claro. ¡Gracias por esto, me ayudaste!
Matt
AddJsonFile no existe en ConfigurationBuilder
Essej
10

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);
        }
    }
Teoman shipahi
fuente
8

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);
        });
Chris Halcrow
fuente
8

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"]
Eric Milliot-Martinez
fuente
Creo que esto debería estar bien siempre que appsettings.jsonesté en el directorio correcto
Ju66ernaut
7

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;
}
Tiago Barroso
fuente
6

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);
Alex Herman
fuente
6

¡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>
Alper Ebicoglu
fuente
"ASP.NET Core" ¿Qué versión?
Steve Smith
5

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)
Monolithcode
fuente
1
¿Cómo podemos obtener los valores de AppSettings en Proyectos de prueba utilizando el mismo enfoque?
S.Siva
2
They just keep changing things. Esta. Casi todas las respuestas en esta página solo se aplican a una versión específica de .Net Core.
Steve Smith
4

.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: ingrese la descripción de la imagen aquí

  1. Finalmente, puedes hacer:

    config ["clave1"]

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

{
    "ConnectionStrings": "myconnection string here",
    "key1": "value here"
}
Gregory
fuente
2

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);
    }
}
jishan siddique
fuente
2

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();
    }
}
Ogglas
fuente
@Ogglas ... ¿cómo la persona que llama de WeatherForecastController () podría obtener la clase que implementa IConfiguration?
Johnny Wu
1

¿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; }
Brian Moore
fuente
1

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);
}
Lapenkov Vladimir
fuente
1

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");
Hamed Naeemaei
fuente
La inyección funciona para controladores, pero ¿qué pasa si quiero usarla en Middleware como aquí ? Por ejemplo, estoy usando Redis como middleware para almacenar en caché las respuestas http.
Alexander Ryan Baggett
1

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;
    }
usuario1321471
fuente
0

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"
  }
}
Justin Gilman
fuente