ASP.NET Core-静态类的访问配置

我想要一个简单的静态类来访问Configuration对象。已经从Startup类的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是任何映射到appsettings.json中MyAppSettings部分的类：

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

appsettings.json：

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

我同意mcbowes，它在docs中，但是第一个示例看起来更像您所需要的...想要：

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


}

StartUp类中的设置DI

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。

该选项模式是一个很好的替代静态配置。在您的情况下，它将如下所示：

appsettings.json

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

SystemUser.cs

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

启动文件

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。

我个人很喜欢此链接中使用的方法

本质上，它只是将静态字段添加到您的options类。

 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

IConfiguration在项目内的任何位置均可注入。但是在静态类的情况下，我正在使用的选项可能只是方法而已... var Configuration = new ConfigurationBuilder() .AddUserSecrets<Startup>() .Build(); 而且，您可以添加必需的部分，例如在上面的代码块中，我添加了'UserSecrets'。