ASP.NET核心访问静态类的配置

Question

我想要一个访问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;

Answer 1

1. 在服务层创建ConfigurationHelper静态类，这样就可以在其他层使用它而无需循环依赖。

public static class ConfigurationHelper
    {
        public static IConfiguration config;
        public static void Initialize(IConfiguration Configuration)
        {
            config = Configuration;
        }
    }

2. 在Startup类的ConfigureServices方法中初始化ConfigurationHelper。

ConfigurationHelper.Initialize(Configuration);

3. 在任何你想要的地方使用它，包括你的静态类

e.g: ConfigurationHelper.config.GetSection("AWS:Accesskey").Value;

Answer 2

基于与上述相同的原理略短的版本...

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

public static IConfiguration StaticConfig { get; private set; }

要在另一个静态类中使用：

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

Answer 3

我也有类似的问题，在阅读了微软的文档后。我已经解决了：

1. 创建静态 ApplicationSettings 类

public static class ApplicationSettings
{
    public const string User = "UserOptions";

    public static UserOptions UserOptions { get; set; } = new UserOptions();

    // other options here...
}

2. 创建选项类

public class UserOptions
{
    public string Username { get; set; };

    public string Password { get; set; };
}

3. 初始化 Program.cs 中的 Options 类

ConfigurationManager configuration = builder.Configuration;

configuration.GetSection(ApplicationSettings.User).Bind(ApplicationSettings.UserOptions);

4. 更新您的 appsettings.json

{
  "UserOptions": {
    "Username": "input_your_username_here",
    "Password": "input_your_password_here"
  }
}

5. 您现在可以在项目中的任何位置调用它

public void MethodA() 
{
    string username = ApplicationSettings.UserOptions.Username;
    string password = ApplicationSettings.UserOptions.Password;
}

public static void MethodB() 
{
    string username = ApplicationSettings.UserOptions.Username;
    string password = ApplicationSettings.UserOptions.Password;
}

希望这可以很好地帮助你。

Answer 4

经过大量研究，这适用于（在 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;
            }
        }
    }
}

启动.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"
   }
 }

Answer 5

我同意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...
    }
}

Answer 6

尽量避免使用静态类并使用 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;
  }

Answer 7

您可以使用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)
        {
        }
    }

Answer 8

这已经说过了，但我还是要说一下。

我相信.Net Core 希望开发者通过依赖注入获得价值。这是我从研究中注意到的，但我也做了一些推测。作为开发人员，我们需要遵循这种范式转变才能很好地使用 .Net Core。

选项模式是静态配置的一个很好的替代方案。在你的情况下，它看起来像这样：

应用程序设置.json

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

系统用户.cs

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

启动.cs

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

要使用 SystemUser 类，我们执行以下操作。

测试控制器.cs

services.Configure<SystemUser>(Configuration);

尽管我们没有使用静态类，但我认为这是满足您需求的最佳选择。否则，您可能必须在 Startup 类中使用静态属性，在我看来这是一个可怕的解决方案。

Answer 9

考虑使用此处的ASP.NET Core 配置说明。

您可以创建一个类来存储您的配置设置，然后访问这些值，如下所示：

_config.UserName

在启动-配置服务中：

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

然后只需在需要的地方注入您的对象即可：

IOptions<Config> config