[Asp.net 5] Configuration-新一代的配置文件（接口定义与基础实现）

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();     } 

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

前面的铺垫已经讲完，下面我们进入正文：

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);  } } 

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

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);  } } 

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();  } } 

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));  } } 

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);  } }