.NET6 ConfigurationManager的实现及使用方式

ConfigurationManager configurationManager = new();
configurationManager.AddJsonFile("appsettings.json",true,reloadOnChange:true);
string serviceName = configurationManager["ServiceName"];
Console.WriteLine(serviceName);

IConfigurationBuilder configurationBuilder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
IConfiguration configuration = configurationBuilder.Build();
string serviceName = configuration["ServiceName"];
Console.WriteLine(serviceName);

public ConfigurationManager Configuration { get; } = new();
//这里注册为了单例模式
Services.AddSingleton<IConfiguration>(_ => Configuration);

public sealed class ConfigurationManager : IConfigurationBuilder, IConfigurationRoot, IDisposable
{
}

ConfigurationManager configurationManager = new();
IConfigurationBuilder configurationBuilder = configurationManager.AddJsonFile("appsettings.json", true, reloadOnChange: true);
//尽管放心的调用Build完全不影响啥
IConfiguration configuration = configurationBuilder.Build();
string serviceName = configuration["ServiceName"];
Console.WriteLine(serviceName);

public class ConfigurationBuilder : IConfigurationBuilder
{
    /// <summary>
    /// 添加的数据源被存放到了这里
    /// </summary>
    public IList<IConfigurationSource> Sources { get; } = new List<IConfigurationSource>();

    public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();

    /// <summary>
    /// 添加IConfigurationSource数据源
    /// </summary>
    /// <returns></returns>
    public IConfigurationBuilder Add(IConfigurationSource source)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }
        Sources.Add(source);
        return this;
    }

    public IConfigurationRoot Build()
    {
        //获取所有添加的IConfigurationSource里的IConfigurationProvider
        var providers = new List<IConfigurationProvider>();
        foreach (var source in Sources)
        {
            var provider = source.Build(this);
            providers.Add(provider);
        }
        //用providers去实例化ConfigurationRoot
        return new ConfigurationRoot(providers);
    }
}

private readonly ConfigurationSources _sources = new ConfigurationSources(this); ;
IConfigurationBuilder IConfigurationBuilder.Add(IConfigurationSource source)
{
    _sources.Add(source ?? throw new ArgumentNullException(nameof(source)));
    return this;
}

/// <summary>
/// 本身是一个IConfigurationSource集合
/// </summary>
private class ConfigurationSources : IList<IConfigurationSource>
{
    private readonly List<IConfigurationSource> _sources = new();
    private readonly ConfigurationManager _config;

    /// <summary>
    /// 因为是ConfigurationManager的内部类所以传递了当前ConfigurationManager实例
    /// </summary>
    /// <param name="config"></param>
    public ConfigurationSources(ConfigurationManager config)
    {
        _config = config;
    }

    /// <summary>
    /// 根据索引获取其中一个IConfigurationSource实例
    /// </summary>
    /// <returns></returns>
    public IConfigurationSource this[int index]
    {
        get => _sources[index];
        set
        {
            _sources[index] = value;
            _config.ReloadSources();
        }
    }

    public int Count => _sources.Count;

    public bool IsReadOnly => false;

    /// <summary>
    /// 这是重点添加配置源
    /// </summary>
    /// <param name="source"></param>
    public void Add(IConfigurationSource source)
    {
        //给自己的IConfigurationSource集合添加
        _sources.Add(source);
        //调用了ConfigurationManager的AddSource方法
        _config.AddSource(source);
    }

    /// <summary>
    /// 实现IList清除操作
    /// </summary>
    public void Clear()
    {
        _sources.Clear();
        //这里可以看到ConfigurationManager的ReloadSources方法很重要
        //通过名字可以看出是刷新配置数据用的
        _config.ReloadSources();
    }

    public void Insert(int index, IConfigurationSource source)
    {
        _sources.Insert(index, source);
        _config.ReloadSources();
    }

    public bool Remove(IConfigurationSource source)
    {
        var removed = _sources.Remove(source);
        _config.ReloadSources();
        return removed;
    }

    public void RemoveAt(int index)
    {
        _sources.RemoveAt(index);
        _config.ReloadSources();
    }

    //这里省略了实现了实现IList接口的其他操作
    //ConfigurationSources本身就是IList<IConfigurationSource>
}

private readonly object _providerLock = new();
private readonly List<IConfigurationProvider> _providers = new();
private readonly List<IDisposable> _changeTokenRegistrations = new();
private void AddSource(IConfigurationSource source)
{
    lock (_providerLock)
    {
        //在IConfigurationSource中得到IConfigurationProvider实例
        var provider = source.Build(this);
        //添加到_providers集合中
        //我们提到过从配置源得到的配置都是通过IConfigurationProvider得到的
        _providers.Add(provider);

        //IConfigurationProvider的Load方法是从配置源中得到配置数据加载到程序内存中
        provider.Load();
        //注册更改令牌操作,使得配置可以进行动态刷新加载
        _changeTokenRegistrations.Add(ChangeToken.OnChange(() => provider.GetReloadToken(), () => RaiseChanged()));
    }
    //添加新的配置源要刷新令牌操作
    RaiseChanged();
}

private ConfigurationReloadToken _changeToken = new();
private void RaiseChanged()
{
    //每次对配置源进行更改操作需要得到新的更改令牌实例，用于可重复通知配置变更相关
    var previousToken = Interlocked.Exchange(ref _changeToken, new ConfigurationReloadToken());
    previousToken.OnReload();
}

private readonly object _providerLock = new();
private void ReloadSources()
{
    lock (_providerLock)
    {
        //释放原有操作
        DisposeRegistrationsAndProvidersUnsynchronized();

        //清除更改令牌
        _changeTokenRegistrations.Clear();
        //清除_providers
        _providers.Clear();

        //重新加载_providers
        foreach (var source in _sources)
        {
            _providers.Add(source.Build(this));
        }

        //重新加载数据添加通知令牌
        foreach (var p in _providers)
        {
            p.Load();
            _changeTokenRegistrations.Add(ChangeToken.OnChange(() => p.GetReloadToken(), () => RaiseChanged()));
        }
    }
    RaiseChanged();
}

IConfigurationRoot IConfigurationBuilder.Build() => this;

public interface IConfiguration
{
    /// <summary>
    /// 通过配置名称获取值
    /// </summary>
    /// <returns></returns>
    string this[string key] { get; set; }

    /// <summary>
    /// 获取一个配置节点
    /// </summary>
    /// <returns></returns>
    IConfigurationSection GetSection(string key);

    /// <summary>
    /// 获取所有子节点
    /// </summary>
    /// <returns></returns>
    IEnumerable<IConfigurationSection> GetChildren();

    /// <summary>
    /// 刷新数据通知
    /// </summary>
    /// <returns></returns>
    IChangeToken GetReloadToken();
}

private readonly object _providerLock = new();
private readonly List<IConfigurationProvider> _providers = new();
/// <summary>
/// 可读可写的操作
/// </summary>
/// <returns></returns>
public string this[string key]
{
    get
    {
        lock (_providerLock)
        {
            //通过在IConfigurationProvider集合中获取配置值
            return ConfigurationRoot.GetConfiguration(_providers, key);
        }
    }
    set
    {
        lock (_providerLock)
        {
            //也可以把值放到IConfigurationProvider集合中
            ConfigurationRoot.SetConfiguration(_providers, key, value);
        }
    }
}

internal static string GetConfiguration(IList<IConfigurationProvider> providers, string key)
{
    //倒序遍历providers，因为Configuration采用的后来者居上的方式，即后注册的Key会覆盖先前注册的Key
    for (int i = providers.Count - 1; i >= 0; i--)
    {
        IConfigurationProvider provider = providers[i];
        //如果找到Key的值就直接返回
        if (provider.TryGet(key, out string value))
        {
            return value;
        }
    }
    return null;
}

internal static void SetConfiguration(IList<IConfigurationProvider> providers, string key, string value)
{
    if (providers.Count == 0)
    {
        throw new InvalidOperationException("");
    }
    //给每个provider都Set这个键值，虽然浪费了一部分内存，但是可以最快的获取
    foreach (IConfigurationProvider provider in providers)
    {
        provider.Set(key, value);
    }
}

public IConfigurationSection GetSection(string key) => new ConfigurationSection(this, key);

private readonly object _providerLock = new();
public IEnumerable<IConfigurationSection> GetChildren()
{
    lock (_providerLock)
    {
        //调用了GetChildrenImplementation方法
        return this.GetChildrenImplementation(null).ToList();
    }
}

internal static IEnumerable<IConfigurationSection> GetChildrenImplementation(this IConfigurationRoot root, string path)
{
    //在当前ConfigurationManager实例中获取到所有的IConfigurationProvider实例
    //然后包装成IConfigurationSection集合
    return root.Providers
        .Aggregate(Enumerable.Empty<string>(),
            (seed, source) => source.GetChildKeys(seed, path))
        .Distinct(StringComparer.OrdinalIgnoreCase)
        .Select(key => root.GetSection(path == null ? key : ConfigurationPath.Combine(path, key)));
}

private readonly ConfigurationBuilderProperties _properties = new ConfigurationBuilderProperties(this);
IDictionary<string, object> IConfigurationBuilder.Properties => _properties;

private class ConfigurationBuilderProperties : IDictionary<string, object>
{
}

protected IDictionary<string, string> Data { get; set; }
protected ConfigurationProvider()
{
    Data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
}