ASP.NET Core'da herhangi bir sınıfta Configuration'a nasıl erişirim?

İçinden gitmiş yapılandırma belgelerinde ASP.NET çekirdeğine. Belgeler, yapılandırmaya uygulamanın herhangi bir yerinden erişebileceğinizi söylüyor.

Şablon tarafından oluşturulan Startup.cs aşağıdadır

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

Dolayısıyla, Startup.cstüm ayarları yapılandırdığımızda, Startup.cs adlı bir özelliği de var.Configuration

Neyi anlayamıyorum bu yapılandırmaya denetleyicide veya uygulamanın herhangi bir yerinde nasıl erişirsiniz? MS seçenekler örüntüsünü kullanmanızı öneriyor ancak benim yalnızca 4-5 anahtar-değer çiftim var, bu yüzden seçenekler kalıbını kullanmak istemiyorum. Sadece uygulamada Yapılandırmaya erişmek istedim. Herhangi bir sınıfa nasıl enjekte edebilirim?

Güncelleme

ASP.NET Core 2.0 kullanmak , uygulamanızın örneğini otomatik olarakIConfiguration bağımlılık ekleme kapsayıcısına ekler . Bu aynı zamanda ile birlikte çalışır ConfigureAppConfigurationüzerinde WebHostBuilder.

Örneğin:

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

    host.Run();
}

IConfigurationÖrneği hizmet koleksiyonuna eklemek, şunlarda bir singleton nesnesi kadar kolaydır ConfigureServices:

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

   // ...
}

Sınıfınızdaki Configurationörnek nerede Startup?

Bu, IConfigurationherhangi bir denetleyiciye veya hizmete enjekte etmenize olanak tanır :

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

Bunu yapmanın doğru yolu:

.NET Core'da bunu IConfigurationSınıf yapıcınıza bir parametre olarak enjekte edebilirsiniz ve kullanılabilir olacaktır.

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

Şimdi, sınıfınızın bir örneğini oluşturmak istediğinizde, sınıfınız enjekte edildiğinden IConfiguration, bunu yapamazsınız new MyClass()çünkü yapıcıya bir IConfigurationparametre enjekte edilmesi gerekir, bu nedenle sınıfınızı şu şekilde enjekte etmeniz gerekir: Enjeksiyon zincirine iyi gelir, bu da iki basit adım anlamına gelir:

Kullanmak istediğiniz - 1) Sınıf / es Ekle IConfigurationiçin, IServiceCollectionen ConfigureServices()yöntemdeStartup.cs

services.AddTransient<MyClass>();

2) Bir örnek tanımlayın - diyelim Controllerve yapıcıyı kullanarak enjekte edelim :

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

Artık _myClass.configurationözgürce eğlenebilmelisin ...

Başka seçenek:

Sınıfları denetleyiciye enjekte etmek zorunda kalmadan hala kullanılabilir hale getirmenin bir yolunu arıyorsanız, o zaman bunu static class, içinde yapılandıracağınız, aşağıdaki Startup.csgibi bir a içinde saklayabilirsiniz :

public static class MyAppData
{
    public static IConfiguration Configuration;
}

Ve Startupkurucunuz şöyle görünmeli:

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

Ardından MyAppData.Configurationprogramınızın herhangi bir yerinde kullanın .

Neden ilk seçeneğin doğru yol olduğunu benimle yüzleşmeyin, deneyimli geliştiricilerin her zaman gereksiz verilerden kaçındığını görebiliyorum ve bellekte her zaman bol miktarda veriye sahip olmanın en iyi uygulama olmadığı anlaşılıyor. ne performans ne de geliştirme için iyi ve belki de sadece ihtiyacınız olana sahip olmak daha güvenlidir.

Bunun eski olduğunu biliyorum, ancak IOptions modellerinin uygulanması nispeten basittir:

1. Yapılandırmadaki ayarlarla eşleşen genel get / set özelliklerine sahip sınıf

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

2. ayarlarınızı kaydedin

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

3. IOptions aracılığıyla enjekte etmek

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

Bunu neden yapmadığından emin değilim.

Bunu şu anda böyle yapıyorum:

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

Ve sonra bunu appsettings.json dosyasından verileri almam gereken yerde kullanıyorum:

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

Ayrıca configurationstartup.cs dosyasında statik hale getirme seçeneği vardır, böylece her yerden kolaylıkla erişebilirsiniz, statik değişkenler uygundur huh!

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

internal static IConfiguration Configuration { get; private set; }

Bu, Yapılandırmayı Startup.Configuration.GetSection...Neler ters gidebilir?

Seçenekler modeli örneğine baktım ve şunu gördüm:

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

Sınıfımın kurucusuna Iconfiguration eklerken, DI aracılığıyla konfigürasyon seçeneklerine erişebildim.

Misal:

public class MyClass{

    private Iconfiguration _config;

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

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

Bunu yapmanın birkaç yolu olabileceğini biliyorum, Core 3.1 kullanıyorum ve en uygun / temiz seçeneği arıyordum ve bunu yaptım:

1. Başlangıç ​​sınıfım varsayılan olarak

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. Appsettings.json böyledir

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

3. Sınıfım bir API Denetleyicisi, bu yüzden önce kullanım referansını ekledim ve ardından IConfiguration arayüzünü enjekte ettim

using Microsoft.Extensions.Configuration;

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

4. Son olarak GetValue yöntemini kullandım

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

8-2017'de Microsoft System.Configuration, .NET CORE v4.4 için çıktı . Şu anda v4.5 ve v4.6 önizlemesi.

.Net Framework'ten CORE'a dönüşüm üzerinde çalışan bizler için bu çok önemlidir. app.configHerhangi bir derlemeden erişilebilen mevcut dosyaları saklamaya ve kullanmaya izin verir . Muhtemelen bunun bir alternatifi olabilir appsettings.json, çünkü Microsoft buna olan ihtiyacı fark etti. FW'de eskisi gibi çalışır. Bir fark var:

Web uygulamalarında, [mesela ASP.NET CORE WEB API] Kullanmak gerek app.configve yok senin için web.config appSettingsveya configurationSection. Kullanmanız gerekebilir, web.configancak yalnızca sitenizi IIS aracılığıyla dağıtıyorsanız. IIS'ye özgü ayarlarıweb.config

Netstandard20 DLL ve Asp.net Core Web Api ile test ettim ve hepsi çalışıyor.

ASP.NET Core'da Options modelini kullanmak gitmenin yoludur. Eklemek istiyorum , startup.cs içindeki seçeneklere erişmeniz gerekiyorsa , bunu şu şekilde yapmanızı tavsiye ederim:

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

Başlangıçta kendi parametrelerini okumam gerekiyor.
Bunun WebHost başlatılmadan önce orada olması gerekir (çünkü parametre dosyasından url / IP'yi ve bağlantı noktasını "dinlemek" ve WebHost'a uygulamak gerekir). Ayrıca, tüm uygulamada herkese açık olan ayarlara ihtiyacım var .

Bir süre aradıktan sonra (tam bir örnek bulunmadı, yalnızca snippet'ler) ve çeşitli deneme yanılma işlemlerinden sonra, bunu kendi .ini dosyasıyla "eski yöntemle" yapmaya karar verdim.
Yani .. .ini dosyasına sahip olun ve / veya "url / IP dinleme" yi kendiniz ayarlayın ve / veya ayarların herkese açık olması gerekir, bu sizin için ...

Tam örnek, çekirdek 2.1 (mvc) için geçerlidir:

Bir .ini dosyası oluşturun - örnek:

[Başlangıç]
URL = http://172.16.1.201:22222
[Parametre]
* Dummy1 = gew7623
Dummy1 = true
Dummy2 = 1

burada Dummyx yalnızca dizeden başka tarih türleri için örnek olarak dahil edilir (ve ayrıca "yanlış param" durumunu test etmek için (aşağıdaki koda bakın).

Global değişkenleri depolamak için projenin köküne bir kod dosyası eklendi:

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

Program.cs'deki kodu değiştirdi (CreateWebHostBuilder () öncesinde):

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

    }
}

Bu yoldan:

• Uygulama yapılandırmam, appsettings.json'dan ayrı ve MS'in gelecek sürümlerde değişiklik yapmasından korkmam gereken hiçbir yan etki yok ;-)
• Ayarlarım global değişkenlerde var
• Her cihaz için "url dinlemek" ayarlayabiliyorum, uygulama çalışıyor (geliştirici makinem, intranet sunucusu ve internet sunucusu)
• Ayarları devre dışı bırakabiliyorum, eski yöntem (önceden bir * belirleyin)
• .İni dosyasında
  bir sorun varsa (ör. Tür uyuşmazlığı) tepki verebilirim Eğer - örneğin - yanlış bir tür ayarlanmışsa (örneğin, * Dummy1 = gew7623 Dummy1 = true yerine etkinleştirilirse) ana bilgisayar kırmızıyı gösterir bilgiler konsolda (istisna dahil) ve uygulamada da tepki verebiliyorum (.ini ile ilgili hatalar varsa GV.bFehler_Ini ist true olarak ayarlanmış)