ASP.NET 5 Configuration

原文： https://docs.asp.net/en/latest/fundamentals/configuration.html
ASP.NET 5支持多种配置选项。 应用的配置文件可以是JSON,XML,INI格式，也可以是来自系统环境变量。而且你还可以写自己的自定义configuration provider。

下载本文示例代码

获取设置configuration

ASP.NET 5的重构了之前依赖于System.Configuration和xml格式的配置文件（如web.config）。

如果你在ASP.NET应用中使用setting的话，建议你只在你应用的Startup类中实例化Configuration。然后使用Option pattern进入独立的settings。

最简单的说，Configuration就是一个source的集合，提供了读写键值对的功能。你最起码得给Configuration配置一个source。下面的代码展示如何使用Configuration做为一个键值对存储：

// assumes using Microsoft.Framework.ConfigurationModel is specified
var builder = new ConfigurationBuilder();
builder.Add(new MemoryConfigurationSource());
var config = builder.Build();
config.Set("somekey", "somevalue");

// do some other work

string setting = config.Get("somekey"); // returns "somevalue"
// or
string setting2 = config["somekey"]; // also returns "somevalue"

注意：

你至少要设置一个source。

通常我们的configuration键存在一个层级关系。ASP.NET5通过使用:号分隔来实现。例如，有如下的appsettings.json文件：

{
"Data": {
"DefaultConnection": {
"ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=aspnet5-WebApplication1-8479b9ce-7b8f-4402-9616-0843bc642f09;Trusted_Connection=True;MultipleActiveResultSets=true"
}
},
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Verbose",
"System": "Information",
"Microsoft": "Information"
}
}
}

通过Data:DefaultConnection:ConnectionString来获取ConnectionString的值。

使用options pattern可以创建你自己的配置类，通过使用options service注入到你的应用中。

注意：

你可以将你的Configuration实例做为一个服务存储起来，但是这样以来你的系统依赖一个单一的configuration，而且所有的配置都在这个单一的configuration里面。可以使用过Options pattern 来避免这个问题。

使用built-in providers

configuration framework的built-it支持JSON, XML, 和INI配置文件，同样还支持内存configuraiton，环境变量configuratin和命令行参数的configuration。可以同时使用多种configuration source。

使用ConfigurationBuilder类来添加configuration source。支持链式写法。

var builder = new ConfigurationBuilder(".");
builder.AddJsonFile("appsettings.json");
builder.AddEnvironmentVariables();
var config = builder.Build();

上面configuration source的顺序非常重要，他决定了优先级。越后添加的configuration source优先级越高。在上面的例子中，如果appsetting.json和环境变量都设置了同一个键，环境变量这个source的优先级会高，会使用环境变量中对应的键值覆盖appsettings.json中的键值。

注意：

环境变量不支持:，我们使用__(两个下划线)来代替。

针对不同的环境（debug,release,test）使用不同的配置文件非常有用。可以通过下面的例子来实现。

public Startup(IHostingEnvironment env)
{
// Set up configuration sources.
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

if (env.IsDevelopment())
{
// For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709 builder.AddUserSecrets();
}

builder.AddEnvironmentVariables();
Configuration = builder.Build();
}

IHostingEnviroment被用来获取当前的环境。在Development环境中，上面的高亮的代码会是appsettings.Development.json，会使用这个文件的值来覆盖其他的文件的值。更多请见Working with Multiple Environments。

警告：

你不应该在源代码或者配置文件中存储如密码一样的敏感数据。这样的敏感数据不应该在项目里面，这样你也不会意外的把他们提交到源代码仓储中去了。更多请见：Working with Multiple Environments and managing Safe Storage of Application Secrets。

下面的例子中在MemoryConfigurationSource中设置了username，但是被命令行参数的username覆盖了:

using System;
using System.Linq;
using Microsoft.Framework.Configuration;

namespace ConfigConsole
{
public class Program
{
public void Main(string[] args)
{
var builder = new ConfigurationBuilder();
Console.WriteLine("Initial Config Sources: " + builder.Sources.Count());

var defaultSettings = new MemoryConfigurationSource();
defaultSettings.Set("username", "Guest");
builder.Add(defaultSettings);
Console.WriteLine("Added Memory Source. Sources: " + builder.Sources.Count());

builder.AddCommandLine(args);
Console.WriteLine("Added Command Line Source. Sources: " + builder.Sources.Count());

var config = builder.Build();
string username = config.Get("username");

Console.WriteLine($"Hello, {username}!");
}
}
}

运行结果如下：

使用Options和configuration对象

使用Options 可以很方便的把任何类转换成一个配置类。 推荐你为不同的应用模块创建对应的配置对象，不要是整个应用只有一个配置对象。

下面是一个简单的MyOptions类：

public class MyOptions
{
public string Option1 { get; set; }
public int Option2 { get; set; }
}

Options可以通过使用IOptions<TOptions>注入到你的应用。如下：

public class HomeController : Controller
{
public HomeController(IOptions<MyOptions> optionsAccessor)
{
Options = optionsAccessor.Options;
}

MyOptions Options { get; }

public IActionResult Index()
{
return View(Options);
}
}

关于依赖注入的信息见，Dependency Injection。

为了使用IOptions<TOption>，你需要在在startup类中有如下设置：

public void ConfigureServices(IServiceCollection services)
{
// Setup options with DI
services.AddOptions();
}

index视图显示option的值：



使用Configure<TOption>来配置你的Options。可以使用委托来配置你的options或者绑定你的options到configuration：

public void ConfigureServices(IServiceCollection services)
{
// Setup options with DI
services.AddOptions();

// Configure MyOptions using config
services.Configure<MyOptions>(Configuration);

// Configure MyOptions using code
services.Configure<MyOptions>(myOptions =>
{
myOptions.Option1 = "value1_from_action";
});

services.AddMvc();
}

当你绑定options到configuration，你options的每一个属性绑定成了configuration的键(property:subproperty:....)。例如，MyOptions.Option1属性绑定到了Options1这个键，读取appsettings.json文件的options1。注意了configuration的键是大小写不敏感的。

每次调用Configuration<TOptions>都会添加一个IConfigureOptions<TOption>服务到服务容器。

对同一个option类可以有多个IConfigureOptions<TOption>，他们的优先级同样依赖于add的顺序。上面的例子中appsettings.json有Option1和Option2，但是Option1的值被下面使用委托的覆盖了。

写自定义providers

除了使用the built-in configuration source providers，我们可以自己写一个自定义的provider。需要继承自ConfigurationSource。

例子: Entity Framework Settings

你可能希望将你的配置存储在数据库里面，通过使用Entity Framework来获取他们。下面的例子，我们创建一个简单的configuration source使用EF来读取来自数据库的键值对。

首先定义ConfigurationValue实体。用来在数据库中存储配置：

public class ConfigurationValue
{
public string Id { get; set; }
public string Value { get; set; }
}

现在需要一个ConfigurationContext来做为DbContext：

public class ConfigurationContext : DbContext
{
public ConfigurationContext(DbContextOptions options) : base(options)
{
}

public DbSet<ConfigurationValue> Values { get; set; }
}

接下来，创建见一个继承自ConfigurationSource的configuration source。覆盖Load方法来加载配置：

public class EntityFrameworkConfigurationSource : ConfigurationSource
{
public EntityFrameworkConfigurationSource(Action<DbContextOptionsBuilder> optionsAction)
{
OptionsAction = optionsAction;
}

Action<DbContextOptionsBuilder> OptionsAction { get; }

public override void Load()
{
var builder = new DbContextOptionsBuilder<ConfigurationContext>();
OptionsAction(builder);

using (var dbContext = new ConfigurationContext(builder.Options))
{
dbContext.Database.EnsureCreated();
Data = !dbContext.Values.Any()
? CreateAndSaveDefaultValues(dbContext)
: dbContext.Values.ToDictionary(c => c.Id, c => c.Value);
}
}

private IDictionary<string, string> CreateAndSaveDefaultValues(ConfigurationContext dbContext)
{
var configValues = new Dictionary<string, string>
{
{ "key1", "value_from_ef_1" },
{ "key2", "value_from_ef_2" }
};
dbContext.Values.AddRange(configValues
.Select(kvp => new ConfigurationValue() { Id = kvp.Key, Value = kvp.Value })
.ToArray());
dbContext.SaveChanges();
return configValues;
}
}

接下来，我们创建一个EntityFrameworkExtensions在里面添加IConfigurationBuilder的一个扩展方法，用于添加configuration source：

public static class EntityFrameworkExtensions
{
public static IConfigurationBuilder AddEntityFramework(this IConfigurationBuilder builder, Action<DbContextOptionsBuilder> setup)
{
return builder.Add(new EntityFrameworkConfigurationSource(setup));
}
}

使用自定义provider：

public class Program
{
public void Main(string[] args)
{
var builder = new ConfigurationBuilder(".");
builder.AddJsonFile("appsettings.json");
builder.AddEnvironmentVariables();
var config = builder.Build();

builder.AddEntityFramework(options => options.UseSqlServer(config["Data:DefaultConnection:ConnectionString"]));
config = builder.Build();

Console.WriteLine("key1={0}", config.Get("key1"));
Console.WriteLine("key2={0}", config.Get("key2"));
Console.WriteLine("key3={0}", config.Get("key3"));

}
}

结果如下：