你的位置:首页 > ASP.net教程

[ASP.net教程][Asp.net 5] Configuration


本系列文章讲的是asp.net 5(Asp.net VNext)中的配置文件部分,工程下载地址为:https://github.com/aspnet/Configuration

本节讲的是Configuration解决方案中的Microsoft.Framework.Configuration和Microsoft.Framework.Configuration.Abstractions俩个工程。

Abstractions

首先我们看下Configuration.Abstractions这个工程的详情:

该工程中只定义了三个接口:IConfiguration、IConfigurationBuilder、IConfigurationSource,是完全为了抽象而设计的工程。

我们在依赖注入(DependencyInjection)篇中也接触过名字为“Abstractions”的工程(链接地址:http://www.cnblogs.com/watermoon2/p/4511269.html),也是只包含必须的接口定义,我们可以推测,微软的命名规则是对于XXXX类工程:

  • Microsoft.Framework.XXXX.Abstractions:定义微软XXXX的必须的抽象
  • Microsoft.Framework.XXXX:定义微软的XXXX的基础实现,内部类多实现Microsoft.Framework.XXXX.Abstractions中接口

配置文件中,肯定少不了配置文件类的基础接口定义:IConfiguration;我们知道新的配置文件实现,支持配置文件有多个来源,可以来自

这个工程代码比较少,下面我就将接口定义罗列如下:

public interface IConfigurationSource  {    bool TryGet(string key, out string value);    void Set(string key, string value);    void Load();    IEnumerable<string> ProduceConfigurationSections(      IEnumerable<string> earlierKeys,      string prefix,      string delimiter);  } public interface IConfigurationBuilder  {    string BasePath { get; }    IEnumerable<IConfigurationSource> Sources { get; }    IConfigurationBuilder Add(IConfigurationSource configurationSource);    IConfiguration Build();  }public interface IConfiguration  {    string this[string key] { get; set; }    string Get(string key);    bool TryGet(string key, out string value);    IConfiguration GetConfigurationSection(string key);    IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSections();    IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSections(string key);    void Set(string key, string value);    void Reload();  }

接口定义

Configuration

我们还是将工程的详情列出:

工程中一共八个cs文件:

1,IConfigurationSource实现类:ConfigurationSource、MemoryConfigurationSource

2,IConfigurationBuilder实现类:ConfigurationBuilder;IConfigurationBuilder扩展方法:ConfigurationHelper

3,IConfiguration实现类:ConfigurationSection、ConfigurationFocus

4,帮助辅助类:ConfigurationKeyComparer、Constants。

一个约定:":"

我们知道配置文件不都是线性的,可能有层次结构(比如传统的配置文件、json的、

  • 根节点对象:“当前key”
  • 非根节点对象:“前缀”+“分隔符”+“当前key"(前缀是当前节点父节点的key值)

所以对于如下的json格式{"root1":"r1","root2":{"sub1":"s2"}},想要获取值是“s2”,所使用的key值是“root2:sub1”;“root2”是父节点的key,“:”是分隔符,“sub1”是当前key。

在这里的分隔符,其实就是定义在Constants类中,public static readonly string KeyDelimiter = ":"; 不过源文件中其他部分并未都直接使用该处定义,在IConfigurationSource的派生类也都是自己定义的“:”;所以想修改分隔符,在现有代码中不是能够只修改Constants中这个全局变量就可以的。所以在源码还有问题的时候,我们还是把分隔符=“:”,作为一个约定(不要试图把分隔符该城其他字符串)。

特殊的排序方式

由于当前key值得字符串可能是由存数字组成,我们希望key值为“1”,“2”,“10”的顺序是“1”,“2”,“10” 而不是“1”,“10”,“2”(字符串默认排序的顺序),所以系统在排序的时候使用了IComparer<string>接口。而IComparer<string>接口的实现类就是ConfigurationKeyComparer

public class ConfigurationKeyComparer : IComparer<string>  {    private const char Separator = ':';    public static ConfigurationKeyComparer Instance { get; } = new ConfigurationKeyComparer();    public int Compare(string x, string y)    {      var xParts = x?.Split(Separator) ?? new string[0];      var yParts = y?.Split(Separator) ?? new string[0];      // Compare each part until we get two parts that are not equal      for (int i = 0; i < Math.Min(xParts.Length, yParts.Length); i++)      {        x = xParts[i];        y = yParts[i];        var value1 = 0;        var value2 = 0;        var xIsInt = x != null && int.TryParse(x, out value1);        var yIsInt = y != null && int.TryParse(y, out value2);        int result = 0;        if (!xIsInt && !yIsInt)        {          // Both are strings          result = string.Compare(x, y, StringComparison.OrdinalIgnoreCase);        }        else if (xIsInt && yIsInt)        {          // Both are int           result = value1 - value2;        }        else        {          // Only one of them is int          result = xIsInt ? -1 : 1;        }        if (result != 0)        {          // One of them is different          return result;        }      }      // If we get here, the common parts are equal.      // If they are of the same length, then they are totally identical      return xParts.Length - yParts.Length;    }  }

ConfigurationKeyComparer

前面的铺垫已经讲完,下面我们进入正文:
ConfigurationBuilder以及ConfigurationHelper

ConfigurationBuilder的功能主要有四点:

  • 能够设置加载的IConfigurationSource源路径目录
  • 能够管理的IConfigurationSource列表
  • 能够加载IConfigurationSource
  • 能够创建IConfiguration

代码中需要注意的也就只有一点:添加新的IConfigurationSource时,首先加载,之后再将IConfigurationSource对象添加到内部IConfigurationSource列表中。

ConfigurationHelper是ConfigurationBuilder的扩展,作用只有一个:

  • 将如果传入路径是相对路径,将IConfigurationSource源路径目录和传入路径进行合并。

ConfigurationBuilder以及ConfigurationHelper源码如下:

public class ConfigurationBuilder : IConfigurationBuilder  {    private readonly IList<IConfigurationSource> _sources = new List<IConfigurationSource>();    public ConfigurationBuilder(params IConfigurationSource[] sources)      : this(null, sources)    {    }    public ConfigurationBuilder(string basePath, params IConfigurationSource[] sources)    {      if (sources != null)      {        foreach (var singleSource in sources)        {          Add(singleSource);        }      }      BasePath = basePath;    }    public IEnumerable<IConfigurationSource> Sources    {      get      {        return _sources;      }    }    public string BasePath    {      get;    }    public IConfigurationBuilder Add(IConfigurationSource configurationSource)    {      return Add(configurationSource, load: true);    }    public IConfigurationBuilder Add(IConfigurationSource configurationSource, bool load)    {      if (load)      {        configurationSource.Load();      }      _sources.Add(configurationSource);      return this;    }    public IConfiguration Build()    {      return new ConfigurationSection(_sources);    }  }

ConfigurationBuilder
 public static class ConfigurationHelper  {    public static string ResolveConfigurationFilePath(IConfigurationBuilder configuration, string path)    {      if (!Path.IsPathRooted(path))      {        if (configuration.BasePath == null)        {          throw new InvalidOperationException(Resources.FormatError_MissingBasePath(            path,            typeof(IConfigurationBuilder).Name,            nameof(configuration.BasePath)));        }        else        {          path = Path.Combine(configuration.BasePath, path);        }      }      return path;    }  }

ConfigurationHelper

ConfigurationSource和MemoryConfigurationSource

ConfigurationSource实现了IConfigurationSource接口,是其他具体的IConfigurationSource父类,该类是抽象类,不能直接实例化。

该类主要提供以下几个功能:

  • 用字典表保存key,value;并且提供get/set方法
  • 提供load方法(该类中是空的虚方法)
  • 给定制定前缀,获取该前缀下的子key(如:对于key值包含如下{“p1”,“p1:p2”,“p1:p3:p4”,“s1”},则通过“p1”可以获取到p2、p3)

MemoryConfigurationSource类继承自ConfigurationSource,提供了额外的方法:获取整个字典表。

[ConfigurationSource是扩展配置文件类型的基类,系统中就是通过继承自该类,实现]

public abstract class ConfigurationSource : IConfigurationSource  {    protected ConfigurationSource()    {      Data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);    }    protected IDictionary<string, string> Data { get; set; }    public virtual bool TryGet(string key, out string value)    {      return Data.TryGetValue(key, out value);    }    public virtual void Set(string key, string value)    {      Data[key] = value;    }    public virtual void Load()    {    }        public virtual IEnumerable<string> ProduceConfigurationSections(      IEnumerable<string> earlierKeys,      string prefix,      string delimiter)    {      return Data        .Where(kv => kv.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))        .Select(kv => Segment(kv.Key, prefix, delimiter))        .Concat(earlierKeys)        .OrderBy(k => k, ConfigurationKeyComparer.Instance);    }    private static string Segment(string key, string prefix, string delimiter)    {      var indexOf = key.IndexOf(delimiter, prefix.Length, StringComparison.OrdinalIgnoreCase);      return indexOf < 0 ? key.Substring(prefix.Length) : key.Substring(prefix.Length, indexOf - prefix.Length);    }  }

ConfigurationSource
public class MemoryConfigurationSource :     ConfigurationSource,     IEnumerable<KeyValuePair<string,string>>  {    public MemoryConfigurationSource()    {    }    public MemoryConfigurationSource(IEnumerable<KeyValuePair<string, string>> initialData)    {      foreach (var pair in initialData)      {        Data.Add(pair.Key, pair.Value);      }    }    public void Add(string key, string value)    {      Data.Add(key, value);    }    public IEnumerator<KeyValuePair<string, string>> GetEnumerator()    {      return Data.GetEnumerator();    }    IEnumerator IEnumerable.GetEnumerator()    {      return GetEnumerator();    }  }

MemoryConfigurationSource

ConfigurationSection和ConfigurationFocus

这两个类是双生类,使用了代理模式:通过GetConfigurationSection等获取IConfiguration方法返回的是ConfigurationFocus代理的ConfigurationSection(ConfigurationBuilder创建的是ConfigurationSection类)。简单的类关系图如下所示:(ConfigurationFocus不会和ConfigurationSource产生关联,会通过ConfigurationSection进行访问)

 

ConfigurationSection类实现的主要功能:

  • 根据key值获取配置信息(包含key值的IConfigurationSource中,ConfigurationBuilder最后添加的IConfigurationSource对象的key值所对应的value值)
  • 根据key值设置配置信息(所有IConfigurationSource文件都会被更新,最后信息不是保存在ConfigurationSection中,而是直接反应在IConfigurationSource上)
  • 重新加载配置源(IConfigurationSource)
  • 根据key值(可以为空)获取<string, IConfiguration>对应的字典表。(系统构建的IConfiguration就是ConfigurationFocus类型)

ConfigurationFocus实现的主要功能:

  • 内部封装ConfigurationSection对象
  • 内部封装当前的前缀信息
  • 根据内部封装的前缀信息+key构造新的key值,之后通过ConfigurationSection获取新key值配置信息/设置新key配置信息
  • 根据内部封装的前缀信息+key构造新的key值,之后通过ConfigurationSection获取新key配置信息。(当前配置信息下一级为key的配置信息)
  • 根据内部封装的前缀信息+key构造新的key值,之后通过ConfigurationSection获取子<string, IConfiguration>对应的字典表。(当先配置信息下一级为key的配置信息的所有子配置信息)
public class ConfigurationSection : IConfiguration  {    private readonly IList<IConfigurationSource> _sources = new List<IConfigurationSource>();    public ConfigurationSection(IList<IConfigurationSource> sources)    {      _sources = sources;    }    public string this[string key]    {      get      {        return Get(key);      }      set      {        Set(key, value);      }    }    public IEnumerable<IConfigurationSource> Sources    {      get      {        return _sources;      }    }    public string Get([NotNull] string key)    {      string value;      return TryGet(key, out value) ? value : null;    }    public bool TryGet([NotNull] string key, out string value)    {      // If a key in the newly added configuration source is identical to a key in a       // formerly added configuration source, the new one overrides the former one.      // So we search in reverse order, starting with latest configuration source.      foreach (var src in _sources.Reverse())      {        if (src.TryGet(key, out value))        {          return true;        }      }      value = null;      return false;    }    public void Set([NotNull] string key, [NotNull] string value)    {      if (!_sources.Any())      {        throw new InvalidOperationException(Resources.Error_NoSources);      }      foreach (var src in _sources)      {        src.Set(key, value);      }    }    public void Reload()    {      foreach (var src in _sources)      {        src.Load();      }    }    public IConfiguration GetConfigurationSection(string key)    {      return new ConfigurationFocus(this, key + Constants.KeyDelimiter);    }    public IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSections()    {      return GetConfigurationSectionsImplementation(string.Empty);    }    public IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSections([NotNull] string key)    {      return GetConfigurationSectionsImplementation(key + Constants.KeyDelimiter);    }    private IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSectionsImplementation(string prefix)    {      var segments = _sources.Aggregate(        Enumerable.Empty<string>(),        (seed, source) => source.ProduceConfigurationSections(seed, prefix, Constants.KeyDelimiter));      var distinctSegments = segments.Distinct();      return distinctSegments.Select(segment => CreateConfigurationFocus(prefix, segment));    }    private KeyValuePair<string, IConfiguration> CreateConfigurationFocus(string prefix, string segment)    {      return new KeyValuePair<string, IConfiguration>(        segment,        new ConfigurationFocus(this, prefix + segment + Constants.KeyDelimiter));    }  }

ConfigurationSection
public class ConfigurationFocus : IConfiguration  {    private readonly string _prefix;    private readonly IConfiguration _root;    public ConfigurationFocus(IConfiguration root, string prefix)    {      _prefix = prefix;      _root = root;    }    public string this[string key]    {      get      {        return Get(key);      }      set      {        Set(key, value);      }    }    public string Get(string key)    {      // Null key indicates that the prefix passed to ctor should be used as a key      if (key == null)      {        // Strip off the trailing colon to get a valid key        var defaultKey = _prefix.Substring(0, _prefix.Length - 1);        return _root.Get(defaultKey);      }      return _root.Get(_prefix + key);    }    public bool TryGet(string key, out string value)    {      // Null key indicates that the prefix passed to ctor should be used as a key      if (key == null)      {        // Strip off the trailing colon to get a valid key        var defaultKey = _prefix.Substring(0, _prefix.Length - 1);        return _root.TryGet(defaultKey, out value);      }      return _root.TryGet(_prefix + key, out value);    }    public IConfiguration GetConfigurationSection(string key)    {      return _root.GetConfigurationSection(_prefix + key);    }    public void Set(string key, string value)    {      _root.Set(_prefix + key, value);    }    public IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSections()    {      return _root.GetConfigurationSections(_prefix.Substring(0, _prefix.Length - 1));    }    public IEnumerable<KeyValuePair<string, IConfiguration>> GetConfigurationSections(string key)    {      return _root.GetConfigurationSections(_prefix + key);    }    public void Reload()    {      throw new InvalidOperationException(Resources.Error_InvalidReload);    }  }

ConfigurationFocus

最后我们将ConfigurationSection和ConfigurationFocus的测试代码贴出,以便能够更好的理解俩个类的关系。

public void CanGetConfigurationSection()    {      // Arrange      var dic1 = new Dictionary<string, string>()        {          {"Data:DB1:Connection1", "MemVal1"},          {"Data:DB1:Connection2", "MemVal2"}        };      var dic2 = new Dictionary<string, string>()        {          {"DataSource:DB2:Connection", "MemVal3"}        };      var dic3 = new Dictionary<string, string>()        {          {"Data", "MemVal4"}        };      var memConfigSrc1 = new MemoryConfigurationSource(dic1);      var memConfigSrc2 = new MemoryConfigurationSource(dic2);      var memConfigSrc3 = new MemoryConfigurationSource(dic3);      var builder = new ConfigurationBuilder();      builder.Add(memConfigSrc1, load: false);      builder.Add(memConfigSrc2, load: false);      builder.Add(memConfigSrc3, load: false);      var config = builder.Build();      string memVal1, memVal2, memVal3, memVal4, memVal5;      bool memRet1, memRet2, memRet3, memRet4, memRet5;      // Act      var configFocus = config.GetConfigurationSection("Data");      memRet1 = configFocus.TryGet("DB1:Connection1", out memVal1);      memRet2 = configFocus.TryGet("DB1:Connection2", out memVal2);      memRet3 = configFocus.TryGet("DB2:Connection", out memVal3);      memRet4 = configFocus.TryGet("Source:DB2:Connection", out memVal4);      memRet5 = configFocus.TryGet(null, out memVal5);      // Assert      Assert.True(memRet1);      Assert.True(memRet2);      Assert.False(memRet3);      Assert.False(memRet4);      Assert.True(memRet5);      Assert.Equal("MemVal1", memVal1);      Assert.Equal("MemVal2", memVal2);      Assert.Equal("MemVal4", memVal5);      Assert.Equal("MemVal1", configFocus.Get("DB1:Connection1"));      Assert.Equal("MemVal2", configFocus.Get("DB1:Connection2"));      Assert.Null(configFocus.Get("DB2:Connection"));      Assert.Null(configFocus.Get("Source:DB2:Connection"));      Assert.Equal("MemVal4", configFocus.Get(null));      Assert.Equal("MemVal1", configFocus["DB1:Connection1"]);      Assert.Equal("MemVal2", configFocus["DB1:Connection2"]);      Assert.Null(configFocus["DB2:Connection"]);      Assert.Null(configFocus["Source:DB2:Connection"]);      Assert.Equal("MemVal4", configFocus[null]);    }