web-dev-qa-db-fra.com

Comment puis-je accéder à la configuration dans n'importe quelle classe d'ASP.NET Core?

J'ai parcouru la documentation de configuration sur le noyau ASP.NET. La documentation indique que vous pouvez accéder à la configuration de n’importe où dans l’application.

Ci-dessous se trouve Startup.cs créé par template

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

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

Qu'est-ce que je ne comprends pas comment accéder à cette configuration dans le contrôleur ou n'importe où dans l'application? MS recommande d'utiliser modèle d'options mais je n'ai que 4 à 5 paires clé-valeur, donc je ne souhaite pas utiliser le modèle d'options. Je voulais juste avoir accès à la configuration dans l'application. Comment puis-je l'injecter dans n'importe quelle classe?

c#asp.net-coreasp.net-core-mvc
66
LP13

Mettre à jour

L'utilisation d'ASP.NET Core 2.0 automatiquement ajoutera l'instance IConfiguration de votre application dans le conteneur d'injection de dépendance. Ceci fonctionne également en conjonction avec ConfigureAppConfiguration sur 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 l’instance IConfiguration à la collection de services en tant qu’objet singleton dans ConfigureServices:

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

   // ...
}

Où Configuration est l'instance de votre classe Startup.

Cela vous permet d’injecter IConfiguration dans n’importe quel contrôleur ou service:

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

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

  1. Classe avec des propriétés get/set publiques 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 sais pas pourquoi tu ne ferais pas ça comme ça.

19
ScottC

La bonne façon de le faire:

Dans .NET Core, vous pouvez injecter la variable IConfiguration en tant que paramètre dans votre constructeur de classe. Elle sera disponible.

public class MyClass 
{
    private IConfiguration configuration;
    public MyClass(IConfiguration configuration)
    {
        ConnectionString = new configuration.GetValue<string>("ConnectionString");
    }

Maintenant, lorsque vous voulez créer une instance de votre classe, puisque celle-ci injecte IConfiguration, vous ne pourrez pas simplement faire new MyClass(), car vous devrez passer le paramètre IConfiguration dans le constructeur. d'injecter également votre classe dans la chaîne d'injection, ce qui signifie deux étapes simples:

1) Ajoutez votre classe/es - où vous voulez utiliser la IConfiguration, à la IServiceCollection à la méthode ConfigureServices() dans Startup.cs

services.AddTransient<MyClass>();

2) Définissez une instance - disons dans la Controller et injectez-la à l'aide du constructeur:

public class MyController : ControllerBase
{
    private MyClass _myClass;
    public MyController(MyClass myClass)
    {
        _myClass = myClass;
    }

Maintenant, vous devriez pouvoir profiter de votre _myClass.configuration librement ...

Une autre option:

Si vous cherchez toujours un moyen de le rendre disponible sans avoir à injecter les classes dans le contrôleur, vous pouvez le stocker dans un static class, que vous configurerez dans le Startup.cs, quelque chose comme:

public static class MyAppData
{
    public static IConfiguration Configuration;
}

Et votre constructeur Startup devrait ressembler à ceci:

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

Ensuite, utilisez MyAppData.Configuration n'importe où dans votre programme.

Ne me dites pas pourquoi la première option est la bonne, je ne peux que voir que des développeurs expérimentés évitent toujours les données erronées tout au long de leur parcours, et il est bien compris que ce n'est pas la meilleure pratique d'avoir des charges de données en mémoire le moment, ce n’est ni bon pour la performance, ni pour le développement, et peut-être est-il aussi plus sûr d’avoir uniquement ce dont vous avez besoin.

5
Mayer Spitzer

J'ai examiné l'échantillon de 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;
    }
...
}

Lors de l'ajout d'Iconfiguration dans le constructeur de ma classe, je pouvais 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
}
2
pursang

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 ensuite, j'utilise ceci pour obtenir les données du fichier appsettings.json:

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

Il y a aussi une option pour rendre configuration static dans startup.cs afin que vous puissiez y accéder facilement n'importe où, les variables statiques sont pratiques hein! 

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

internal static IConfiguration Configuration { get; private set; }

Cela rend la configuration accessible n'importe où en utilisant Startup.Configuration.GetSection... Qu'est-ce qui peut aller mal?

1
konzo

En 8-2017, Microsoft est sorti avec System.Configuration pour .NET CORE v4.4. Actuellement v4.5 et aperçu v4.6.

Pour ceux d'entre nous qui travaillons à la transformation de .Net Framework en CORE, c'est essentiel. Il permet de conserver et d'utiliser les fichiers app.config actuels, accessibles depuis n'importe quel assemblage. C'est probablement même une alternative à appsettings.json, puisque Microsoft en a compris la nécessité. Cela fonctionne comme avant dans FW. Il y a une différence:

Dans les applications Web, [p. Ex. ASP.NET CORE WEB API] vous devez utiliser app.config et non web.config pour votre appSettings ou configurationSection. Vous devrez peut-être utiliser web.config, mais uniquement si vous déployez votre site via IIS. Vous placez les paramètres spécifiques à IIS dans web.config

Je l'ai testé avec netstandard20 DLL et Asp.net Core Web Api et tout fonctionne.

0
T.S.