Comment 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.

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

Donc, dans Startup.csnous configurons tous les paramètres, Startup.cs a également une propriété nomméeConfiguration

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

Mettre à jour

L'utilisation d'ASP.NET Core 2.0 ajoutera automatiquement l' IConfigurationinstance de votre application dans le conteneur d'injection de dépendances. Cela fonctionne également en conjonction avec ConfigureAppConfigurationsur 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 l' IConfigurationinstance à la collection de services en tant qu'objet singleton dans ConfigureServices:

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

   // ...
}

Où Configurationest l'instance dans votre Startupclasse.

Cela vous permet d'injecter IConfigurationdans n'importe quel contrôleur ou service:

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

La bonne façon de le faire:

Dans .NET Core, vous pouvez injecter le en IConfigurationtant que paramètre dans votre constructeur de classe, et il 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 votre classe est injectée dans IConfiguration, vous ne pourrez pas simplement le faire new MyClass(), car elle a besoin d'un IConfigurationparamètre injecté dans le constructeur, vous devrez donc injecter votre classe comme bien à la chaîne d'injection, ce qui signifie deux étapes simples:

1) Ajoutez vos classes - où vous voulez utiliser le IConfiguration, IServiceCollectionà la ConfigureServices()méthode dansStartup.cs

services.AddTransient<MyClass>();

2) Définissez une instance - disons dans le Controller, et injectez-la en utilisant le constructeur:

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

Vous devriez maintenant pouvoir profiter _myClass.configurationlibrement de votre ...

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 Startupconstructeur devrait ressembler à ceci:

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

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

Ne me demandez pas pourquoi la première option est la bonne façon, je peux juste voir que les développeurs expérimentés évitent toujours les données inutiles en cours de route, et il est bien entendu que ce n'est pas la meilleure pratique d'avoir des tonnes de données disponibles en mémoire tout le temps, ce n'est pas non plus bon pour les performances et ni pour le développement, et il est peut-être aussi plus sûr de n'avoir avec vous que ce dont vous avez besoin.

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 sais pas pourquoi vous ne feriez pas cela.

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 j'utilise ceci où j'ai besoin d'obtenir les données du fichier appsettings.json:

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

Il existe également une option pour rendre configurationstatique 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 ne va pas?

J'ai regardé dans l'exemple 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
}

Je sais qu'il peut y avoir plusieurs façons de faire cela, j'utilise Core 3.1 et je cherchais l'option optimale / plus propre et j'ai fini par faire ceci:

1. Ma classe de démarrage est par défaut

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

2. Mon appsettings.json est comme ça

{
  "CompanySettings": {
    "name": "Fake Co"
  }
}

3. Ma classe est un contrôleur d'API, j'ai donc d'abord ajouté la référence d'utilisation, puis j'ai injecté l'interface IConfiguration

using Microsoft.Extensions.Configuration;

public class EmployeeController 
{
    private IConfiguration _configuration;
    public EmployeeController(IConfiguration configuration)
    {
        _configuration = configuration;
    }
}

4. Enfin, j'ai utilisé la méthode GetValue

public async Task<IActionResult> Post([FromBody] EmployeeModel form)
{
    var companyName = configuration.GetValue<string>("CompanySettings:name");
    // companyName = "Fake Co"
}

En 8-2017, Microsoft a sorti System.Configurationpour .NET CORE v4.4. Actuellement v4.5 et v4.6.

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

Dans les applications Web, [par exemple l'API WEB ASP.NET CORE] vous devez utiliser app.configet non web.config pour votre appSettingsou configurationSection. Vous devrez peut-être utiliser, web.configmais uniquement si vous déployez votre site via IIS. Vous placez des paramètres spécifiques à IIS dansweb.config

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

L'utilisation du modèle Options dans ASP.NET Core est la solution. Je veux juste ajouter, si vous avez besoin d' accéder aux options de votre startup.cs , je vous recommande de le faire de cette façon:

CosmosDbOptions.cs:

public class CosmosDbOptions
{
    public string ConnectionString { get; set; }
}

Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    // This is how you can access the Connection String:
    var connectionString = Configuration.GetSection(nameof(CosmosDbOptions))[nameof(CosmosDbOptions.ConnectionString)];
}

Je dois lire mes propres paramètres au démarrage.
Cela doit être là avant que le WebHost ne démarre (car j'ai besoin de l'url / IP et du port "pour écouter" du fichier de paramètres et de l'appliquer au WebHost). De plus, j'ai besoin des paramètres publics dans l'ensemble de l'application.

Après avoir cherché pendant un certain temps (aucun exemple complet trouvé, seulement des extraits de code) et après plusieurs essais et erreurs, j'ai décidé de le faire à l'ancienne avec un propre fichier .ini.
Donc .. si vous voulez utiliser votre propre fichier .ini et / ou définissez le "pour écouter url / IP" votre propre et / ou avez besoin des paramètres publics, ceci est pour vous ...

Exemple complet, valable pour le noyau 2.1 (mvc):

Créez un fichier .ini - exemple:

[Démarrage]
URL = http://172.16.1.201:22222
[Paramètre]
* Dummy1 = gew7623
Dummy1 = true
Dummy2 = 1

où les Dummyx ne sont inclus qu'à titre d'exemple pour d'autres types de date que string (et aussi pour tester le cas «mauvais param» (voir code ci-dessous).

Ajout d'un fichier de code à la racine du projet, pour stocker les variables globales:

namespace MatrixGuide
{
    public static class GV
    {
        // In this class all gobals are defined

        static string _cURL;
        public static string cURL // URL (IP + Port) on that the application has to listen
        {
            get { return _cURL; }
            set { _cURL = value; }
        }

        static bool _bdummy1;
        public static bool bdummy1 // 
        {
            get { return _bdummy1; }
            set { _bdummy1 = value; }
        }

        static int _idummy1;
        public static int idummy1 // 
        {
            get { return _idummy1; }
            set { _idummy1 = value; }
        }

        static bool _bFehler_Ini;
        public static bool bFehler_Ini // 
        {
            get { return _bFehler_Ini; }
            set { _bFehler_Ini = value; }
        }

        // add further  GV variables here..
    }
    // Add further classes here... 
}

Modification du code dans program.cs (avant CreateWebHostBuilder ()):

namespace MatrixGuide
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // Read .ini file and overtake the contend in globale
            // Do it in an try-catch to be able to react to errors
            GV.bFehler_Ini = false;
            try
            {
                var iniconfig = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddIniFile("matrixGuide.ini", optional: false, reloadOnChange: true)
                .Build();
                string cURL = iniconfig.GetValue<string>("Startup:URL");
                bool bdummy1 = iniconfig.GetValue<bool>("Parameter:Dummy1");
                int idummy2 = iniconfig.GetValue<int>("Parameter:Dummy2");
                //
                GV.cURL = cURL;
                GV.bdummy1 = bdummy1;
                GV.idummy1 = idummy2;
            }
            catch (Exception e)
            {
                GV.bFehler_Ini = true;
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("!! Fehler beim Lesen von MatrixGuide.ini !!");
                Console.WriteLine("Message:" + e.Message);
                if (!(e.InnerException != null))
                {
                    Console.WriteLine("InnerException: " + e.InnerException.ToString());
                }

                Console.ForegroundColor = ConsoleColor.White;
            }
            // End .ini file processing
            //
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>() //;
            .UseUrls(GV.cURL, "http://localhost:5000"); // set the to use URL from .ini -> no impact to IISExpress

    }
}

Par ici:

• Ma configuration d'application est séparée de appsettings.json et je n'ai aucun effet secondaire à craindre, si MS fait des changements dans les versions futures ;-)
• J'ai mes paramètres dans des variables globales
• Je suis en mesure de définir "pour écouter l'url" pour chaque appareil, l'application est activée (ma machine de développement, le serveur intranet et le serveur Internet)
• Je peux désactiver les paramètres, à l'ancienne (il suffit de définir un * avant)
• Je suis capable de réagir, si quelque chose ne va pas dans le fichier .ini (par exemple, incompatibilité de type)
  Si - par exemple - un mauvais type est défini (par exemple, le * Dummy1 = gew7623 est activé à la place du Dummy1 = true) l'hôte est rouge les informations sont sur la console (y compris l'exception) et je peux également réagir dans l'application (GV.bFehler_Ini est défini sur true, s'il y a des erreurs avec le .ini)