ASP.NET Core - доступ до конфігурації зі статичного класу

Я хочу простий статичний клас, який отримує доступ до об'єкта Configuration. Вся інформація про конфігурацію вже прочитана з файлу appsettings.json у класі запуску. Мені просто потрібен простий спосіб отримати до нього доступ. Чи можливо це?

namespace MyNamespace
{
    public static class Config
    {
        public string Username => Configuration["Username"];
        public string Password => Configuration["Password"];
    }
}

Де завгодно в додатку:

string username = Config.Username;
string password = Config.Password;

Трохи коротша версія, заснована на тому ж принципі, що і вище ...

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

public static IConfiguration StaticConfig { get; private set; }

Для використання в іншому статичному класі:

string connString = Startup.StaticConfig.GetConnectionString("DefaultConnection");

Після довгих досліджень це працює (в ASPNetCore 2.2) для доступу до конфігурації appsettings.json із статичного класу, але з якихось причин appsettings.development.json більше не завантажується належним чином, але це може щось інше у моєму проекті зіпсувати. ReloadOnChange працює. Як бонус він також має IHostingEnvironment та IHttpContextAccessor. Поки це працює, нещодавно я вирішив повернутися до більш підхідного DI, щоб слідувати зміні парадигми, як згадували інші.

Отже, ось один із багатьох способів отримати доступ до деяких матеріалів DI (включаючи конфігурацію) у статичному класі:

AppServicesHelper.cs:

public static class AppServicesHelper
{
        static IServiceProvider services = null;

        /// <summary>
        /// Provides static access to the framework's services provider
        /// </summary>
        public static IServiceProvider Services
        {
            get { return services; }
            set
            {
                if (services != null)
                {
                    throw new Exception("Can't set once a value has already been set.");
                }
                services = value;
            }
        }

        /// <summary>
        /// Provides static access to the current HttpContext
        /// </summary>
        public static HttpContext HttpContext_Current
        {
            get
            {
                IHttpContextAccessor httpContextAccessor = services.GetService(typeof(IHttpContextAccessor)) as IHttpContextAccessor;
                return httpContextAccessor?.HttpContext;
            }
        }

        public static IHostingEnvironment HostingEnvironment
        {
            get
            {
                return services.GetService(typeof(IHostingEnvironment)) as IHostingEnvironment;
            }
        }

        /// <summary>
        /// Configuration settings from appsetting.json.
        /// </summary>
        public static MyAppSettings Config
        {
            get
            {
                //This works to get file changes.
                var s = services.GetService(typeof(IOptionsMonitor<MyAppSettings>)) as IOptionsMonitor<MyAppSettings>;
                MyAppSettings config = s.CurrentValue;

                return config;
            }
        }
    }
}

Startup.cs:

public Startup(IHostingEnvironment env)
{
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true)
                .AddEnvironmentVariables();
            Configuration = builder.Build();
 }

 public void ConfigureServices(IServiceCollection services)
 {
//...

        services.AddHttpContextAccessor();//For HttpContext.

        // Register the IOptions object
        services.Configure<MyAppSettings>(Configuration.GetSection(nameof(MyAppSettings)));

        //Explicitly register the settings object by delegating to the IOptions object so that it can be accessed globally via AppServicesHelper.
        services.AddSingleton(resolver => resolver.GetRequiredService<IOptionsMonitor<MyAppSettings>>().CurrentValue);
 }

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
//...
   AppServicesHelper.Services = app.ApplicationServices;
//...
}

Контролер:

public class MyController: Controller
{
   public MyController()
   {
   }

   public MyAppSettings Config => AppServicesHelper.Config;

   public async Task<IActionResult> doSomething()
   {
            testModel tm = await myService.GetModel(Config.Setting_1);
            return View(tm);
   }
}

Інша бібліотека класів:

public static class MyLibraryClass
{
     public static string GetMySetting_ => AppServicesHelper.Config.Setting_1; 
     public static bool IsDev => AppServicesHelper.HostingEnvironment.IsDevelopment();
}

MyAppSettings.cs - це будь-який клас, який відображається у розділі MyAppSettings у appsettings.json:

public class MyAppSettings
{
    public string Setting_1 {get;set;}
}

appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "MyAppSettings": {
      "Setting_1": "something"
   }
 }

Я згоден з mcbowes, це в документах , але перший приклад більше схожий на те, що вам потрібно ... хочете:

public class Program
{
    public static IConfigurationRoot Configuration { get; set; }
    public static void Main(string[] args = null)
    {
        var builder = new ConfigurationBuilder()
             .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json");

        Configuration = builder.Build();

        Console.WriteLine($"option1 = {Configuration["option1"]}");

        // Edit:
        IServiceCollection services = new ServiceCollection();
        services.AddOptions();
        services.Configure<HelloWorldOptions>(_configuration.GetSection("HelloWorld"));
        // And so on...
    }
}

Спробуйте уникати використання статичного класу та використовуйте DI

namespace MyNamespace {

  public interface IConfig {
    string Username { get; }
    string Password { get; }
  }


  public class Config : IConfig {
    public Config(IConfiguration configuration) {
      _configuration = configuration;
    }
    readonly IConfiguration _configuration;
    public string Username => _configuration["Username"];
    public string Password => _configuration["Password"];
  }


}

Налаштування DI в класі StartUp

public class Startup {
  public void ConfigureServices(IServiceCollection services) {
    //...
    services.AddTransient<IConfig, Config>(); 
    ...
  }
}

І використовувати його так

  public class TestUsage {
    public TestUsage(IConfig config) {
      _config = config;
    }
    readonly IConfig _config;
    public string Username => _config.Username;
    public string Password => _config.Password;
  }

Ви можете використовувати шаблон Signleton для доступу до своїх конфігурацій з будь-якого місця

    public class ConnectionStrings
    {
        private ConnectionStrings()
        {
        }
        // property with getter only will not work.
        public static ConnectionStrings Instance { get; protected set; } = new ConnectionStrings();

        public string DatabaseConnection { get; set; }
    }

і у вашому стартап-класі

    public class Startup
    {
        private readonly IConfiguration configuration;

        public Startup(IConfiguration configuration)
        {
            this.configuration = configuration;
            configuration.GetSection("ConnectionStrings").Bind(ConnectionStrings.Instance);
        }

        public void ConfigureServices(IServiceCollection services)
        {
        }

        public void Configure(IApplicationBuilder app)
        {
        }
    }

Це вже було сказано, але я збираюся це сказати.

Я вважаю .Net Core хоче, щоб розробники отримували значення за допомогою Dependency Inject. Це те, що я помітив у своїх дослідженнях, але я також трохи припускаю. Як розробники, нам потрібно слідувати цій зміні парадигми, щоб добре використовувати .Net Core.

Options Pattern є гарною альтернативою для статичної конфігурації. У вашому випадку це буде виглядати так:

appsettings.json

{
  "Username": "MyUsername",
  "Password": "Password1234"
}

SystemUser.cs

public class SystemUser 
{
  public string Username { get; set; } = "";
  public string Password { get; set; } = "";
}

Startup.cs

services.Configure<SystemUser>(Configuration);

А щоб використовувати клас SystemUser, ми робимо наступне.

TestController.cs

public class TestController : Controller 
{
  private readonly SystemUser systemUser;

  public TestController(IOptionsMonitor<SystemUser> systemUserOptions)
  {
    this.systemUser = systemUserOptions.CurrentValue;
  }

  public void SomeMethod() 
  {
    var username = this.systemUser.Username; // "MyUsername"
    var password = this.systemUser.Password; // "Password1234"
  }
}

Хоча ми не використовуємо статичний клас, я думаю, що це найкраща альтернатива, яка відповідає вашим потребам. В іншому випадку, можливо, доведеться використовувати статичну властивість всередині класу Startup, що є страшним рішенням imo.

Особисто мені подобається метод, використаний у цьому посиланні

По суті, це просто додавання статичного поля до вашого класу параметрів.

 public class WeblogConfiguration
 {
    public static WeblogConfiguration Current;

    public WeblogConfiguration()
    {
        Current = this;
    }
} 

Тоді в будь-якому статичному класі ви можете зробити:

WeblogConfiguration.Current

Простий і дуже прямий

Якщо ви використовуєте змінні середовища як свою конфігурацію , ви можете отримати доступ до змінної середовища безпосередньо, а не через об'єкт конфігурації.

using System;

namespace My.Example
{
    public static class GetPaths
    {
        private static readonly string MyPATH = 
            Environment.GetEnvironmentVariable("PATH");

        private static readonly string MySpecialPath =
            Environment.GetEnvironmentVariable("PREFIX_SpecialPath");
        ...
    }
}

Я думаю, ви могли б використовувати функцію розширення, щось подібне

public static string ConfigToSomeThing(this IConfiguration config, int value)
        {
            return config[value.ToString()] ?? "";
        }

Потім у будь-якому місці, просто введення IConfiguration та використання методу розширення

_systemConfiguration.ConfigToSomeThing(123);

Я щойно створив нижчий клас:

    /// <summary>
    /// 
    /// </summary>
    public static class ConfigurationManager
    {
        /// <summary>
        /// 
        /// </summary>
        public sealed class ConfigurationManagerAppSettings
        {
            /// <summary>
            /// 
            /// </summary>
            internal ConfigurationManagerAppSettings() { }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public string this[string key] => (TheConfiguration ?? throw new Exception("Set ConfigurationManager.TheConfiguration in Startup.cs")).GetSection($"AppSettings:{key}").Value;
        }

        /// <summary>
        /// 
        /// </summary>
        public static IConfiguration? TheConfiguration { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public static readonly ConfigurationManagerAppSettings AppSettings = new ConfigurationManagerAppSettings();
    }

і нижче код:

public class Startup
    {
        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) {
            ConfigurationManager.TheConfiguration = Configuration;

Ось спосіб отримати значення конфігурації зі сторінки NET.Core, не маючи статичного посилання на них, але в той же час передаючи їх іншим статичним функціям, що викликаються з нестатичного класу.

У верхній частині вашого нестатичного класу додайте це:

private readonly IConfiguration _configuration;

Потім у функцію конструктора введіть існуючу конфігурацію як вхід до функції: IConfiguration configuration

Потім призначте конфігурацію змінній лише для читання всередині функції конструктора: _configuration = configuration;

Ось приклад того, як це повинно виглядати:

public class IndexModel : PageModel
{
    private readonly IConfiguration _configuration;

    public IndexModel(IConfiguration configuration)
    {
        _configuration = configuration;
    }
}

Після цього ви можете посилатися на конфігурацію в будь-якій функції класу, посилаючись на _configuration, і навіть потім можете передавати це іншим статичним функціям, які ви викликаєте з інших класів:

public async Task OnGetAsync()
{
    AnotherClass.SomeFunction(_configuration);
}

Тоді у викликаному статичному класі я можу використовувати значення конфігурації:

public static string SomeFunction(IConfiguration configuration)
{
    string SomeValue = configuration.GetSection("SomeSectionOfConfig")["SomeValue"];
}

У мене є клас, який викликає деякі збережені процедури для перегляду та внесення змін та передає значення параметрів з appsettings.json, використовуючи цей підхід.

Подумайте про використання інструкцій тут для конфігурації ASP.NET Core.

Ви можете створити клас для зберігання ваших налаштувань конфігурації, а потім отримати доступ до значень, приблизно так:

_config.UserName

Під час запуску - ConfigureServices:

services.Configure<Config>(Configuration.GetSections("General"));

Тоді просто введіть свій об’єкт куди завгодно, як:

IOptions<Config> config

Конфігурація IC є ін’єкційною в будь-якому місці проекту. Але у випадку зі статичним класом я використовую опцію, яка, можливо, підходить ... var Configuration = new ConfigurationBuilder() .AddUserSecrets<Startup>() .Build(); І, ви можете додати потрібний розділ, наприклад, у цьому блоці коду вище, я додав 'UserSecrets'.