public class TestCancellationChangeToken
{
    private CancellationTokenSource tokenSource;

    /// <summary>
    /// 獲取CancellationChangeToken實(shí)例方法
    /// </summary>
    public CancellationChangeToken CreatChanageToken()
    {
        tokenSource = new CancellationTokenSource();
        return new CancellationChangeToken(tokenSource.Token);
    }

    /// <summary>
    /// 取消CancellationTokenSource
    /// </summary>
    public void CancelToken()
    {
        tokenSource.Cancel();
    }
}

//聲明類的實(shí)例
TestCancellationChangeToken cancellationChangeToken = new TestCancellationChangeToken();
ChangeToken.OnChange(() => cancellationChangeToken.CreatChanageToken(), () =>
{
    System.Console.WriteLine($"{DateTime.Now:HH:mm:ss}被觸發(fā)可一次");
});

//模擬多次調(diào)用CancelToken
for (int i = 0; i < 3; i++)
{
    Thread.Sleep(1000);
    cancellationChangeToken.CancelToken();
}

public class TestCompositeChangeToken
{
    //聲明一個CancellationTokenSource集合
    private List<CancellationTokenSource> _cancellationTokenSources;

    /// <summary>
    /// 獲取CompositeChangeToken實(shí)例方法
    /// </summary>
    public CompositeChangeToken CreatChanageToken()
    {
        //初始化三個CancellationTokenSource實(shí)例
        var firstCancellationTokenSource = new CancellationTokenSource();
        var secondCancellationTokenSource = new CancellationTokenSource();
        var threeCancellationTokenSource = new CancellationTokenSource();

        //分別注冊一個回調(diào)操作用于演示
        firstCancellationTokenSource.Token.Register(() => System.Console.WriteLine("firstCancellationTokenSource被取消"));
        secondCancellationTokenSource.Token.Register(() => System.Console.WriteLine("secondCancellationTokenSource被取消"));
        threeCancellationTokenSource.Token.Register(() => System.Console.WriteLine("threeCancellationTokenSource被取消"));

        //加入到集合還
        _cancellationTokenSources = new List<CancellationTokenSource>
        {
            firstCancellationTokenSource,
            secondCancellationTokenSource,
            threeCancellationTokenSource
        };

        //生成CancellationChangeToken集合
        var cancellationChangeTokens = _cancellationTokenSources.Select(i => new CancellationChangeToken(i.Token)).ToList();
        //傳遞給CompositeChangeToken
        var compositeChangeToken = new CompositeChangeToken(cancellationChangeTokens);
        //給CompositeChangeToken實(shí)例注冊一個取消回調(diào)方便演示
        compositeChangeToken.RegisterChangeCallback(state => System.Console.WriteLine("compositeChangeToken被取消"),null);

        return compositeChangeToken;
    }

    /// <summary>
    /// 取消CancellationTokenSource
    /// </summary>
    public void CancelToken()
    {
        //方便演示效果在_cancellationTokenSources集合隨便獲取一個取消
        _cancellationTokenSources[new Random().Next(_cancellationTokenSources.Count)].Cancel();
    }
}

//聲明類的實(shí)例
TestCompositeChangeToken compositeChangeToken = new TestCompositeChangeToken();
ChangeToken.OnChange(() => compositeChangeToken.CreatChanageToken(), () =>
{
    System.Console.WriteLine($"{DateTime.Now:HH:mm:ss}被觸發(fā)可一次");
});

//模擬多次調(diào)用CancelToken
for (int i = 0; i < 3; i++)
{
    Thread.Sleep(1000);
    compositeChangeToken.CancelToken();
}

public interface IChangeToken
{
    /// <summary>
    /// 用來標(biāo)識是否發(fā)生過更改
    /// </summary>
    bool HasChanged { get; }

    /// <summary>
    /// 指示令牌是否支持回調(diào)
    /// </summary>
    bool ActiveChangeCallbacks { get; }

    /// <summary>
    /// 當(dāng)令牌取消時執(zhí)行的回調(diào)
    /// </summary>
    /// <param name="callback">回調(diào)執(zhí)行委托</param>
    /// <param name="state">回調(diào)委托的參數(shù)</param>
    /// <returns>An <see cref="IDisposable"/> that is used to unregister the callback.</returns>
    IDisposable RegisterChangeCallback(Action<object> callback, object state);
}

public class CancellationChangeToken : IChangeToken
{
    /// <summary>
    /// 唯一構(gòu)造函數(shù)通過CancellationChangeToken初始化
    /// </summary>
    public CancellationChangeToken(CancellationToken cancellationToken)
    {
        Token = cancellationToken;
    }

    /// <summary>
    /// 因?yàn)樗峭ㄟ^CancellationToken實(shí)現(xiàn)具備回調(diào)的能力
    /// </summary>
    public bool ActiveChangeCallbacks { get; private set; } = true;

    /// <summary>
    /// 根據(jù)CancellationToken的IsCancellationRequested屬性判斷令牌是否已取消
    /// </summary>
    public bool HasChanged => Token.IsCancellationRequested;

    /// <summary>
    /// 接收傳遞進(jìn)來的CancellationToken
    /// </summary>
    private CancellationToken Token { get; }

    /// <summary>
    /// 注冊回調(diào)操作
    /// </summary>
    /// <returns></returns>
    public IDisposable RegisterChangeCallback(Action<object> callback, object state)
    {
        try
        {
            //本質(zhì)還是通過CancellationToken完成它回調(diào)操作的功能
            return Token.UnsafeRegister(callback, state);
        }
        catch (ObjectDisposedException)
        {
            ActiveChangeCallbacks = false;
        }
        return NullDisposable.Instance;
    }

    private class NullDisposable : IDisposable
    {
        public static readonly NullDisposable Instance = new NullDisposable();

        public void Dispose()
        {
        }
    }
}

public static IDisposable OnChange(Func<IChangeToken> changeTokenProducer, Action changeTokenConsumer)
{
    return new ChangeTokenRegistration<Action>(changeTokenProducer, callback => callback(), changeTokenConsumer);
}

public static IDisposable OnChange<TState>(Func<IChangeToken> changeTokenProducer, Action<TState> changeTokenConsumer, TState state)
{
    return new ChangeTokenRegistration<TState>(changeTokenProducer, changeTokenConsumer, state);
}

private class ChangeTokenRegistration<TState> : IDisposable
{
    //生產(chǎn)IChangeToken實(shí)例的委托
    private readonly Func<IChangeToken> _changeTokenProducer;
    //回調(diào)委托
    private readonly Action<TState> _changeTokenConsumer;
    //回調(diào)參數(shù)
    private readonly TState _state;
    public ChangeTokenRegistration(Func<IChangeToken> changeTokenProducer, Action<TState> changeTokenConsumer, TState state)
    {
        _changeTokenProducer = changeTokenProducer;
        _changeTokenConsumer = changeTokenConsumer;
        _state = state;

        //執(zhí)行changeTokenProducer得到IChangeToken實(shí)例
        IChangeToken token = changeTokenProducer();
        //調(diào)用RegisterChangeTokenCallback方法傳遞IChangeToken實(shí)例
        RegisterChangeTokenCallback(token);
    }
}

private void RegisterChangeTokenCallback(IChangeToken token)
{
    //給IChangeToken實(shí)例注冊回調(diào)操作
    //回調(diào)操作正是執(zhí)行當(dāng)前ChangeTokenRegistration實(shí)例的OnChangeTokenFired方法
    IDisposable registraton = token.RegisterChangeCallback(s => ((ChangeTokenRegistration<TState>)s).OnChangeTokenFired(), this);
    SetDisposable(registraton);
}

private void OnChangeTokenFired()
{
    //獲取一個新的IChangeToken實(shí)例
    IChangeToken token = _changeTokenProducer();
    try
    {
        //執(zhí)行注冊的回調(diào)操作
        _changeTokenConsumer(_state);
    }
    finally
    {
        //又調(diào)用了RegisterChangeTokenCallback注冊當(dāng)前IChangeToken實(shí)例
        RegisterChangeTokenCallback(token);
    }
}

private IDisposable _disposable;
private static readonly NoopDisposable _disposedSentinel = new NoopDisposable();
private void SetDisposable(IDisposable disposable)
{
    //讀取_disposable實(shí)例
    IDisposable current = Volatile.Read(ref _disposable);
    //如果當(dāng)前_disposable實(shí)例等于_disposedSentinel實(shí)例則說明當(dāng)前ChangeTokenRegistration已被釋放，
    //則直接釋放IChangeToken實(shí)例然后返回
    if (current == _disposedSentinel)
    {
        disposable.Dispose();
        return;
    }

    //線程安全交換，如果之前_disposable的值等于_disposedSentinel說明被釋放過了
    //則釋放IChangeToken實(shí)例
    IDisposable previous = Interlocked.CompareExchange(ref _disposable, disposable, current);
    if (previous == _disposedSentinel)
    {
        disposable.Dispose();
    }
    //說明沒有被釋放過
    else if (previous == current)
    {
    }
    //說明別的線程操作了dispose則直接異常
    else
    {
        throw new InvalidOperationException("Somebody else set the _disposable field");
    }
}

public void Dispose()
{
    //因?yàn)開disposable初始值是null所以把NoopDisposable實(shí)例賦值給_disposable并調(diào)用Dispose方法
    Interlocked.Exchange(ref _disposable, _disposedSentinel).Dispose();
}

public class CompositeChangeToken : IChangeToken
{
      public IReadOnlyList<IChangeToken> ChangeTokens { get; }
      public bool ActiveChangeCallbacks { get; }
      public CompositeChangeToken(IReadOnlyList<IChangeToken> changeTokens)
      {
          ChangeTokens = changeTokens ?? throw new ArgumentNullException(nameof(changeTokens));
          //遍歷傳入的IChangeToken集合
          for (int i = 0; i < ChangeTokens.Count; i++)
          {
              /**
               * 如果集合中存在任何一個IChangeToken實(shí)例ActiveChangeCallbacks為true
               * 則CompositeChangeToken的ActiveChangeCallbacks也為true
               * 因?yàn)镃ompositeChangeToken可以關(guān)聯(lián)IChangeToken集合中的任何一個有效實(shí)例
               */
              if (ChangeTokens[i].ActiveChangeCallbacks)
              {
                  ActiveChangeCallbacks = true;
                  break;
              }
          }
      }
}

private CancellationTokenSource _cancellationTokenSource;
public IDisposable RegisterChangeCallback(Action<object> callback, object state)
{
    //核心方法
    EnsureCallbacksInitialized();
   //這里的CancellationTokenSource注冊CompositeChangeToken的回調(diào)操作
    return _cancellationTokenSource.Token.Register(callback, state);
}

private static readonly Action<object> _onChangeDelegate = OnChange;
private bool _registeredCallbackProxy;
private List<IDisposable> _disposables;
private readonly object _callbackLock = new object();
private void EnsureCallbacksInitialized()
{
   //判斷是否已使用RegisterChangeCallback注冊過回調(diào)操作，如果不是第一次則直接返回
    if (_registeredCallbackProxy)
    {
        return;
    }

   //加鎖 意味著這個操作要線程安全
    lock (_callbackLock)
    {
        if (_registeredCallbackProxy)
        {
            return;
        }
        //實(shí)例化CancellationTokenSource，因?yàn)镽egisterChangeCallback方法里再用
        _cancellationTokenSource = new CancellationTokenSource();
        _disposables = new List<IDisposable>();
        //循環(huán)要關(guān)聯(lián)的IChangeToken集合
        for (int i = 0; i < ChangeTokens.Count; i++)
        {
            //判斷注冊進(jìn)來的IChangeToken實(shí)例是否支持回調(diào)操作
            if (ChangeTokens[i].ActiveChangeCallbacks)
            {
                //給IChangeToken實(shí)例注冊回調(diào)操作執(zhí)行_onChangeDelegate委托
                IDisposable disposable = ChangeTokens[i].RegisterChangeCallback(_onChangeDelegate, this);
                //返回值加入IDisposable集合
                _disposables.Add(disposable);
            }
        }
       //標(biāo)識注冊過了，防止重復(fù)注冊引發(fā)的多次觸發(fā)
        _registeredCallbackProxy = true;
    }
}

private static void OnChange(object state)
{
    //獲取傳遞的CompositeChangeToken實(shí)例
    var compositeChangeTokenState = (CompositeChangeToken)state;
    //判斷CancellationTokenSource是否被初始化過
    if (compositeChangeTokenState._cancellationTokenSource == null)
    {
        return;
    }

    //加鎖 說明這一步是線程安全操作
    lock (compositeChangeTokenState._callbackLock)
    {
        try
        {
            /**
             * 取消當(dāng)前實(shí)例的CancellationTokenSource
             * 這樣才能執(zhí)行CompositeChangeToken注冊的回調(diào)操作
             */
            compositeChangeTokenState._cancellationTokenSource.Cancel();
        }
        catch
        {
        }
    }
    //獲取EnsureCallbacksInitialized方法中注冊的集合,即IChangeToken集合的回調(diào)返回值集合
    List<IDisposable> disposables = compositeChangeTokenState._disposables;
    //不為null則通過循環(huán)的方式挨個釋放掉
    Debug.Assert(disposables != null);
    for (int i = 0; i < disposables.Count; i++)
    {
        disposables[i].Dispose();
    }
}

public bool HasChanged
{
    get
    {
        //如果當(dāng)前實(shí)例的CancellationTokenSource被取消過則說明當(dāng)前CompositeChangeToken已被取消
        if (_cancellationTokenSource != null && _cancellationTokenSource.Token.IsCancellationRequested)
        {
            return true;
        }

        //循環(huán)注冊進(jìn)來的關(guān)聯(lián)的IChangeToken集合
        for (int i = 0; i < ChangeTokens.Count; i++)
        {
            //如果存在關(guān)聯(lián)的IChangeToken實(shí)例有被取消的那么也認(rèn)為當(dāng)前CompositeChangeToken已被取消
            if (ChangeTokens[i].HasChanged)
            {
                //調(diào)用OnChange是否關(guān)聯(lián)的IChangeToken實(shí)例
                OnChange(this);
                return true;
            }
        }
        //否則則沒被取消過
        return false;
    }
}

public class ConfigurationReloadToken : IChangeToken
{
    //內(nèi)部定義了CancellationTokenSource實(shí)例
    private CancellationTokenSource _cts = new CancellationTokenSource();

    public bool ActiveChangeCallbacks => true;

    public bool HasChanged => _cts.IsCancellationRequested;

    /// <summary>
    /// 給當(dāng)前的CancellationTokenSource實(shí)例注冊操作
    public IDisposable RegisterChangeCallback(Action<object> callback, object state) => _cts.Token.Register(callback, state);

    /// <summary>
    /// 添加OnReload方法,供外部取消使用
    /// </summary>
    public void OnReload() => _cts.Cancel();
}

private ConfigurationReloadToken _changeToken = new ConfigurationReloadToken();
private void RaiseChanged()
{
    //直接交換一個新的ConfigurationReloadToken實(shí)例
    ConfigurationReloadToken previousToken = Interlocked.Exchange(ref _changeToken, new ConfigurationReloadToken());
    //取消上一個ConfigurationReloadToken實(shí)例實(shí)現(xiàn)更改通知操作
    previousToken.OnReload();
}

public IChangeToken GetReloadToken() => _changeToken;