Comment accéder à la configuration dans n'importe quelle classe en ASP.NET Core ?

Question

Je suis passé par documentation de configuration sur ASP.NET core. La documentation indique que vous pouvez accéder à la configuration depuis n'importe quel endroit de l'application.

Voici le fichier Startup.cs créé par le modèle

public class Startup
{
    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.IsEnvironment("Development"))
        {
            // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
            builder.AddApplicationInsightsSettings(developerMode: true);
        }

        builder.AddEnvironmentVariables();
        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; }

    // This method gets called by the runtime. Use this method to add services to the container
    public void ConfigureServices(IServiceCollection services)
    {
        // Add framework services.
        services.AddApplicationInsightsTelemetry(Configuration);

        services.AddMvc();
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        app.UseApplicationInsightsRequestTelemetry();

        app.UseApplicationInsightsExceptionTelemetry();

        app.UseMvc();
    }
}

Ainsi, en Startup.cs nous configurons tous les paramètres, Startup.cs a également une propriété nommée Configuration

Ce que je n'arrive pas à comprendre, c'est comment accéder à cette configuration dans le contrôleur ou n'importe où dans l'application ? MS recommande d'utiliser schéma des options mais je n'ai que 4 ou 5 paires clé-valeur et j'aimerais ne pas utiliser le modèle d'options. Je veux juste avoir accès à la configuration dans l'application. Comment puis-je l'injecter dans n'importe quelle classe ?

Answer 1

Mise à jour

Utilisation d'ASP.NET Core 2.0 automatiquement ajouter le IConfiguration de votre application dans le conteneur d'injection de dépendances. Cela fonctionne également en conjonction avec ConfigureAppConfiguration sur le WebHostBuilder .

Par exemple :

public static void Main(string[] args)
{
    var host = WebHost.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration(builder =>
        {
            builder.AddIniFile("foo.ini");
        })
        .UseStartup<Startup>()
        .Build();

    host.Run();
}

---

C'est aussi simple que d'ajouter le IConfiguration à la collection de services en tant qu'objet singleton dans la section ConfigureServices :

public void ConfigureServices(IServiceCollection services)
{
   services.AddSingleton<IConfiguration>(Configuration);

   // ...
}

Donde Configuration est l'instance dans votre Startup classe.

Cela vous permet d'injecter IConfiguration dans tout contrôleur ou service :

public class HomeController
{
   public HomeController(IConfiguration configuration)
   {
      // Use IConfiguration instance
   }
}

Answer 2

Je sais que c'est vieux, mais étant donné les modèles IOptions, c'est relativement simple à mettre en œuvre :

1. Classe avec des propriétés publiques get/set qui correspondent aux paramètres de la configuration.

   public class ApplicationSettings
   {
       public string UrlBasePath { get; set; }
   }

2. enregistrer vos paramètres

   public void ConfigureServices(IServiceCollection services)
   {
    ...
    services.Configure<ApplicationSettings>(Configuration.GetSection("ApplicationSettings"));
   ...
   }

3. injecter via IOptions

   public class HomeController
   {
      public HomeController(IOptions<ApplicationSettings> appSettings)
      { ...
       appSettings.Value.UrlBasePath
       ...
       // or better practice create a readonly private reference
       }
    }

Je ne vois pas pourquoi vous ne feriez pas ça.

Answer 3

Il est également possible de faire configuration static dans startup.cs de sorte que ce que vous pouvez y accéder n'importe où avec facilité, les variables statiques sont pratiques hein !

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

internal static IConfiguration Configuration { get; private set; }

La configuration est ainsi accessible partout grâce à Startup.Configuration.GetSection... Qu'est-ce qui peut mal tourner ?

Answer 4

Je le fais comme ça en ce moment :

// Requires NuGet package Microsoft.Extensions.Configuration.Json

using Microsoft.Extensions.Configuration;
using System.IO;

namespace ImagesToMssql.AppsettingsJson
{
    public static class AppSettingsJson
    {           
        public static IConfigurationRoot GetAppSettings()
        {
            string applicationExeDirectory = ApplicationExeDirectory();

            var builder = new ConfigurationBuilder()
            .SetBasePath(applicationExeDirectory)
            .AddJsonFile("appsettings.json");

            return builder.Build();
        }

        private static string ApplicationExeDirectory()
        {
            var location = System.Reflection.Assembly.GetExecutingAssembly().Location;
            var appRoot = Path.GetDirectoryName(location);

            return appRoot;
        }
    }
}

Et puis je l'utilise lorsque j'ai besoin de récupérer les données du fichier appsettings.json :

var appSettingsJson = AppSettingsJson.GetAppSettings();
// appSettingsJson["keyName"]

Answer 5

J'ai regardé dans l'échantillon du modèle d'options et j'ai vu ceci :

public class Startup
{
    public Startup(IConfiguration config)
    {
        // Configuration from appsettings.json has already been loaded by
        // CreateDefaultBuilder on WebHost in Program.cs. Use DI to load
        // the configuration into the Configuration property.
        Configuration = config;
    }
...
}

En ajoutant Iconfiguration dans le constructeur de ma classe, j'ai pu accéder aux options de configuration via DI.

Exemple :

public class MyClass{

    private Iconfiguration _config;

    public MyClass(Iconfiguration config){
        _config = config;
    }

    ... // access _config["myAppSetting"] anywhere in this class
}