CompositeChangeToken.cs

private readonly object _callbackLock = new object();
private List<CallbackState> _callbacks = new List<CallbackState>();
private bool _registeredCallbackProxy;
private bool _canBeChanged = true;

public IDisposable RegisterChangeCallback(Action<object> callback, object state)
{
    if (!_canBeChanged)
    {
        return NullDispoable.Singleton;
    }
    
    var changeTokenState = new ChangeTokenState(callback, state);
    Callbacks.Add(changeTokenState);

    EnsureCallbacksRegistered();
    
    return changeTokenState.CallbackDisposable;
}

private void EnsureCallbacksRegistered()
{
    lock (_callbackLock)
    {
        if (_registeredCallbackProxy)
        {
            return;
        }
        
        for (var i = 0; i < _changeTokens.Count; i++)
        {
            _changeTokens[i].RegisterChangeCallback(OnChange, null);
        }
    }
}

private void OnChange(object state)
{
    _canBeChanged = false;
    lock (_callbackLock)
    {
        for (var i = 0; i < _callbacks.Count; i++)
        {
            var callbackState = _callbacks[i];
            if (callbackState.Disposable.Disposed)
            {
                continue;
            }
            
            callbackState.Callback(callbackState.State);
        }
    }
}

private class CallbackDisposable : IDisposable
{
    public bool Disposed { get; private set; }
    
    public void Dispose()
    {
        Disposed = true;
    }
}

private struct CallbackState
{
    public CallbackState(Action<object> callback, object state, CallbackDisposable disposable)
    {
        
    }
    
    public Action<object> Callback { get; }
    public object State { get; }
    public CallbackDisposable Disposable { get; }
}