Jak uzyskać dostęp do konfiguracji w dowolnej klasie w ASP.NET Core?

Przejrzałem dokumentację konfiguracji dotyczącą ASP.NET core. Dokumentacja mówi, że możesz uzyskać dostęp do konfiguracji z dowolnego miejsca w aplikacji.

Poniżej znajduje się plik Startup.cs utworzony przez szablon

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

Więc Startup.cskonfigurujemy wszystkie ustawienia, Startup.cs ma również właściwość o nazwieConfiguration

Czego nie jestem w stanie zrozumieć, jak uzyskujesz dostęp do tej konfiguracji w kontrolerze lub w dowolnym miejscu w aplikacji? MS zaleca użycie wzorca opcji, ale mam tylko 4-5 par klucz-wartość, więc nie chciałbym używać wzorca opcji. Chciałem tylko mieć dostęp do konfiguracji w aplikacji. Jak wstrzyknąć to w dowolnej klasie?

Aktualizacja

Użycie ASP.NET Core 2.0 spowoduje automatyczne dodanie IConfigurationwystąpienia aplikacji w kontenerze iniekcji zależności. Działa to również w połączeniu z ConfigureAppConfigurationnaWebHostBuilder .

Na przykład:

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

    host.Run();
}

Jest to tak proste, jak dodanie IConfigurationinstancji do kolekcji usług jako pojedynczego obiektu w ConfigureServices:

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

   // ...
}

Gdzie Configurationjest instancja w twojej Startupklasie.

Pozwala to na wprowadzenie IConfigurationdowolnego kontrolera lub usługi:

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

Właściwy sposób, aby to zrobić:

W .NET Core możesz wstrzyknąć IConfigurationparametr jako parametr do konstruktora klasy i będzie on dostępny.

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

Teraz, gdy chcesz utworzyć instancję swojej klasy, ponieważ twoja klasa zostanie wstrzyknięta IConfiguration, nie będziesz w stanie tego zrobić new MyClass(), ponieważ wymaga ona IConfigurationparametru wstrzykniętego do konstruktora, więc będziesz musiał wstrzyknąć swoją klasę jako dobrze do łańcucha wtrysku, co oznacza dwa proste kroki:

1) Dodaj swoje klasy (klasy) - gdzie chcesz użyć IConfiguration, do metody IServiceCollectionat ConfigureServices()wStartup.cs

services.AddTransient<MyClass>();

2) Zdefiniuj instancję - powiedzmy w Controller, i wstrzyknij ją za pomocą konstruktora:

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

Teraz powinieneś móc _myClass.configurationswobodnie cieszyć się ...

Inna opcja:

Jeśli nadal szukasz sposobu na udostępnienie go bez konieczności wstrzykiwania klas do kontrolera, możesz zapisać go w pliku static class, który skonfigurujesz wStartup.cs , coś takiego:

public static class MyAppData
{
    public static IConfiguration Configuration;
}

Twój Startupkonstruktor powinien wyglądać tak:

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

Następnie użyj MyAppData.Configuration dowolnego miejsca w programie.

Nie konfrontuj mnie, dlaczego pierwsza opcja jest właściwa, widzę tylko, że doświadczeni programiści zawsze unikają danych śmieciowych po drodze i dobrze rozumiemy, że nie jest najlepszą praktyką, aby mieć mnóstwo danych dostępnych w pamięci przez cały czas, nie jest to również dobre dla wydajności ani dla rozwoju, a być może bezpieczniej jest mieć tylko to, czego potrzebujesz.

Wiem, że to jest stare, ale biorąc pod uwagę wzorce IOptions, jest stosunkowo proste do zaimplementowania:

1. Klasa z publicznymi właściwościami get / set, które pasują do ustawień w konfiguracji

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

2. zarejestruj swoje ustawienia

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

3. wstrzyknąć przez IOptions

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

Nie jestem pewien, dlaczego po prostu tego nie zrobiłeś.

Istnieje również opcja configurationstatyczna w pliku startup.cs, dzięki czemu zmienne statyczne są wygodne, jeśli masz do nich łatwy dostęp, hę!

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

internal static IConfiguration Configuration { get; private set; }

Dzięki temu konfiguracja jest dostępna w dowolnym miejscu przy użyciu Startup.Configuration.GetSection...Co może pójść nie tak?

W tej chwili robię to tak:

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

A potem używam tego, gdzie muszę pobrać dane z pliku appsettings.json:

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

Zajrzałem do próbki wzoru opcji i zobaczyłem to:

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

Dodając Iconfiguration w konstruktorze mojej klasy, mogłem uzyskać dostęp do opcji konfiguracyjnych przez DI.

Przykład:

public class MyClass{

    private Iconfiguration _config;

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

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

Wiem, że może być na to kilka sposobów, używam Core 3.1 i szukałem optymalnej / czystszej opcji i skończyło się na tym:

1. Moja klasa startowa jest domyślnie

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. Mój plik appsettings.json wygląda tak

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

3. Moja klasa jest kontrolerem API, więc najpierw dodałem odwołanie using, a następnie wstrzyknąłem interfejs IConfiguration

using Microsoft.Extensions.Configuration;

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

4. Wreszcie użyłem metody GetValue

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

W 8-2017 Microsoft wypuścił System.Configurationdla .NET CORE v4.4. Obecnie wersja zapoznawcza wersji 4.5 i 4.6 .

Dla tych z nas, którzy pracują nad transformacją z .Net Framework do CORE, jest to niezbędne. Umożliwia przechowywanie i używanie aktualnych app.configplików, do których można uzyskać dostęp z dowolnego zestawu. Prawdopodobnie może to być nawet alternatywa dlaappsettings.json , ponieważ Microsoft zdał sobie sprawę z takiej potrzeby. Działa tak samo jak wcześniej w FW. Jest jedna różnica:

W aplikacjach internetowych [np. ASP.NET CORE WEB API] musisz używać, app.configa nie web.config dla swojego appSettingslub configurationSection. Może być konieczne użycie, web.configale tylko w przypadku wdrażania witryny za pośrednictwem usług IIS. Umieszczasz ustawienia specyficzne dla usług IIS w programieweb.config

Przetestowałem to z netstandard20 DLL i Asp.net Core Web Api i wszystko działa.

Najlepszym sposobem jest użycie wzorca opcji w ASP.NET Core . Chcę tylko dodać, jeśli potrzebujesz dostępu do opcji w swoim startup.cs , polecam zrobić to w ten sposób:

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

Muszę odczytać własne parametry przy starcie.
To musi być tam przed uruchomieniem WebHost (ponieważ potrzebuję adresu URL / IP „do nasłuchiwania” i portu z pliku parametrów i zastosowania go do hosta WebHost). Ponadto potrzebuję ustawień publicznych w całej aplikacji.

Po dłuższym wyszukiwaniu (nie znaleziono pełnego przykładu, tylko fragmenty) i po różnych próbach i błędach, zdecydowałem się zrobić to w „stary sposób” z własnym plikiem .ini.
Więc ... jeśli chcesz użyć swojego mieć własny plik .ini i / lub ustaw "do nasłuchiwania url / IP" swoje własne i / lub potrzebujesz publicznych ustawień, to jest dla ciebie ...

Kompletny przykład, ważny dla rdzenia 2.1 (MVC):

Utwórz plik .ini - przykład:

[Startup]
URL = http://172.16.1.201:22222
[Parametr]
* Dummy1 = gew7623
Dummy1 = true
Dummy2 = 1

przy czym Dummyx są uwzględniane tylko jako przykład dla innych typów dat niż string (a także do testowania przypadku „zły parametr” (patrz kod poniżej).

Dodano plik kodu w katalogu głównym projektu do przechowywania zmiennych globalnych:

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

Zmieniono kod w program.cs (przed 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

    }
}

Tą drogą:

• Moja konfiguracja aplikacji jest oddzielona od pliku appsettings.json i nie mam żadnych skutków ubocznych, których należy się obawiać, jeśli MS wprowadzi zmiany w przyszłych wersjach ;-)
• Mam swoje ustawienia w zmiennych globalnych
• Jestem w stanie ustawić „adres URL do nasłuchiwania” dla każdego urządzenia, na którym działa aplikacja (moja maszyna deweloperska, serwer intranetowy i serwer internetowy)
• Jestem w stanie dezaktywować ustawienia, stary sposób (po prostu ustaw * przed)
• Jestem w stanie zareagować, jeśli coś jest nie tak w pliku .ini (np.
  Niezgodność typów) Jeśli - np. - ustawiony jest niewłaściwy typ (np. * Dummy1 = gew7623 jest aktywowany zamiast Dummy1 = true) host wyświetla kolor czerwony informacje są na konsoli (w tym wyjątek) i mogę zareagować również w aplikacji (GV.bFehler_Ini jest ustawione na true, jeśli wystąpią błędy z .ini)