ManualOptionMonitor.cs

    public class ManualOptionMonitor<T> : IOptionsMonitor<T>
    {
        private readonly Dictionary<int, Action<T, string>> _listeners = new Dictionary<int, Action<T, string>>();
        private volatile int _nextId;

        private T _currentValue;
        public T CurrentValue
        {
            get
            {
                return _currentValue;
            }
            set
            {
                if (!value.Equals(_currentValue))
                {
                    _currentValue = value;
                    lock (_listeners)
                    {
                        foreach (var listener in _listeners.Values)
                        {
                            try
                            {
                                listener(_currentValue, null);
                            } catch { }
                        }
                    }
                }
            }
        }

        public T Get(string name) => CurrentValue;

        private event Action<T, string> _onChanged;

        public IDisposable OnChange(Action<T, string> listener)
        {
            lock (_listeners)
            {
                _nextId++;
                _listeners.Add(_nextId, listener);
                return new OptionMonitorRegistration(this, _nextId);
            }
        }

        private void Unregister(int id)
        {
            lock (_listeners)
            {
                _listeners.Remove(id);
            }
        }

        public struct OptionMonitorRegistration : IDisposable
        {
            private ManualOptionMonitor<T> _optionMonitor;
            private int _id;

            public OptionMonitorRegistration(ManualOptionMonitor<T> optionMonitor, int id)
            {
                _optionMonitor = optionMonitor;
                _id = id;
            }

            public void Dispose()
            {
                _optionMonitor.Unregister(_id);
            }
        }
    }