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);
//盡管放心的調(diào)用Build完全不影響啥
IConfiguration configuration = configurationBuilder.Build();
string serviceName = configuration["ServiceName"];
Console.WriteLine(serviceName);

public class ConfigurationBuilder : IConfigurationBuilder
{
    /// <summary>
    /// 添加的數(shù)據(jù)源被存放到了這里
    /// </summary>
    public IList<IConfigurationSource> Sources { get; } = new List<IConfigurationSource>();

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

    /// <summary>
    /// 添加IConfigurationSource數(shù)據(jù)源
    /// </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去實(shí)例化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>
/// 本身是一個(gè)IConfigurationSource集合
/// </summary>
private class ConfigurationSources : IList<IConfigurationSource>
{
    private readonly List<IConfigurationSource> _sources = new();
    private readonly ConfigurationManager _config;

    /// <summary>
    /// 因?yàn)槭荂onfigurationManager的內(nèi)部類所以傳遞了當(dāng)前ConfigurationManager實(shí)例
    /// </summary>
    /// <param name="config"></param>
    public ConfigurationSources(ConfigurationManager config)
    {
        _config = config;
    }

    /// <summary>
    /// 根據(jù)索引獲取其中一個(gè)IConfigurationSource實(shí)例
    /// </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>
    /// 這是重點(diǎn)添加配置源
    /// </summary>
    /// <param name="source"></param>
    public void Add(IConfigurationSource source)
    {
        //給自己的IConfigurationSource集合添加
        _sources.Add(source);
        //調(diào)用了ConfigurationManager的AddSource方法
        _config.AddSource(source);
    }

    /// <summary>
    /// 實(shí)現(xiàn)IList清除操作
    /// </summary>
    public void Clear()
    {
        _sources.Clear();
        //這里可以看到ConfigurationManager的ReloadSources方法很重要
        //通過名字可以看出是刷新配置數(shù)據(jù)用的
        _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();
    }

    //這里省略了實(shí)現(xiàn)了實(shí)現(xiàn)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實(shí)例
        var provider = source.Build(this);
        //添加到_providers集合中
        //我們提到過從配置源得到的配置都是通過IConfigurationProvider得到的
        _providers.Add(provider);

        //IConfigurationProvider的Load方法是從配置源中得到配置數(shù)據(jù)加載到程序內(nèi)存中
        provider.Load();
        //注冊更改令牌操作,使得配置可以進(jìn)行動(dòng)態(tài)刷新加載
        _changeTokenRegistrations.Add(ChangeToken.OnChange(() => provider.GetReloadToken(), () => RaiseChanged()));
    }
    //添加新的配置源要刷新令牌操作
    RaiseChanged();
}

private ConfigurationReloadToken _changeToken = new();
private void RaiseChanged()
{
    //每次對配置源進(jìn)行更改操作需要得到新的更改令牌實(shí)例，用于可重復(fù)通知配置變更相關(guān)
    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));
        }

        //重新加載數(shù)據(jù)添加通知令牌
        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>
    /// 獲取一個(gè)配置節(jié)點(diǎn)
    /// </summary>
    /// <returns></returns>
    IConfigurationSection GetSection(string key);

    /// <summary>
    /// 獲取所有子節(jié)點(diǎn)
    /// </summary>
    /// <returns></returns>
    IEnumerable<IConfigurationSection> GetChildren();

    /// <summary>
    /// 刷新數(shù)據(jù)通知
    /// </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，因?yàn)镃onfiguration采用的后來者居上的方式，即后注冊的Key會(huì)覆蓋先前注冊的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("");
    }
    //給每個(gè)provider都Set這個(gè)鍵值，雖然浪費(fèi)了一部分內(nèi)存，但是可以最快的獲取
    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)
    {
        //調(diào)用了GetChildrenImplementation方法
        return this.GetChildrenImplementation(null).ToList();
    }
}

internal static IEnumerable<IConfigurationSection> GetChildrenImplementation(this IConfigurationRoot root, string path)
{
    //在當(dāng)前ConfigurationManager實(shí)例中獲取到所有的IConfigurationProvider實(shí)例
    //然后包裝成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);
}