如何在不使用 Rx 框架的情况下限制事件的速度

Question

我想限制事件的速度，如何在不使用 Microsoft Rx 框架的情况下实现这一点。我在 Rx 的帮助下完成了这项工作。但我正在尝试的是，我需要根据时隙限制 Map 的 View changed 事件。是否可以在不使用 Rx 的情况下实现相同的功能。

我不允许使用 Rx，我必须保持二进制大小尽可能小。

Answer 1

例如，如果您的事件是 EventHandler<EventArgs> 类型，则此方法有效。它为你的事件处理程序创建了一个被限制的包装器：

private EventHandler<EventArgs> CreateThrottledEventHandler(
    EventHandler<EventArgs> handler, 
    TimeSpan throttle)
{   
    bool throttling = false;
    return (s,e) =>
    {
        if(throttling) return;              
        handler(s,e);
        throttling = true;
        Task.Delay(throttle).ContinueWith(_ => throttling = false);
    };
}

像这样附加：

this.SomeEvent += CreateThrottledEventHandler(
    (s,e) => Console.WriteLine("I am throttled!"),
    TimeSpan.FromSeconds(5));

不过，如果您以后需要将其与-= 断开连接，您应该存储从CreateThrottledEventHandler 返回的处理程序。

Answer 2

我认为以下要求在“节流”事件处理程序中是必不可少的：

• 立即引发 first 事件。
• 在限制期内发生的后续事件被忽略。
• 一旦限制期结束，保证在限制期内发生的最后事件。

考虑到这些要求，之前接受的答案并不令人满意；它正确地满足了前两个要求，但不能保证最终会引发最后一个事件。我认为这一点特别重要，因为高频引发的事件通常代表“状态变化”和/或“用户请求”；我们总是希望收到状态或用户交互变化的最新更新。

为了满足所有这些要求，我创建了自己的通用“ThrottledEventHandler”类。

public class ThrottledEventHandler<TArgs>
    where TArgs : EventArgs
{
    private readonly EventHandler<TArgs> _innerHandler;
    private readonly EventHandler<TArgs> _outerHandler;
    private readonly Timer _throttleTimer;

    private readonly object _throttleLock = new object();
    private Action _delayedHandler = null;

    public ThrottledEventHandler(EventHandler<TArgs> handler, TimeSpan delay)
    {
        _innerHandler = handler;
        _outerHandler = HandleIncomingEvent;
        _throttleTimer = new Timer(delay.TotalMilliseconds);
        _throttleTimer.Elapsed += Timer_Tick;
    }

    private void HandleIncomingEvent(object sender, TArgs args)
    {
        lock (_throttleLock)
        {
            if (_throttleTimer.Enabled)
            {
                _delayedHandler = () => SendEventToHandler(sender, args);
            }
            else
            {
                SendEventToHandler(sender, args);
            }
        }
    }

    private void SendEventToHandler(object sender, TArgs args)
    {
        if (_innerHandler != null)
        {
            _innerHandler(sender, args);
            _throttleTimer.Start();
        }
    }

    private void Timer_Tick(object sender, EventArgs args)
    {
        lock (_throttleLock)
        {
            _throttleTimer.Stop();
            if (_delayedHandler != null)
            {
                _delayedHandler();
                _delayedHandler = null;
            }
        }
    }

    public static implicit operator EventHandler<TArgs>(ThrottledEventHandler<TArgs> throttledHandler)
    {
        return throttledHandler._outerHandler;
    }
}

用法如下所示：

myObject.MyFrequentlyRaisedEvent += new ThrottledEventHandler(MyActualEventHandler, TimeSpan.FromMilliseconds(50));

Answer 3

这是一个 Throttle 方法，灵感来自 James World 的 CreateThrottledEventHandler 方法，它模仿了 Rx Throttle/Debounce 运算符的行为。它仅传播在dueTime 不活动期之后发生的事件。这意味着，如果源事件快速连续引发，并且它们之间没有大于dueTime 的时间间隔，则不会传播任何事件。

/// <summary>Ignores events that are followed by another event within
/// a specified relative time duration.</summary>
public static EventHandler<TEventArgs> Throttle<TEventArgs>(
    EventHandler<TEventArgs> handler,
    TimeSpan dueTime)
{
    System.Threading.Timer timer = null;
    return (s, e) =>
    {
        var newTimer = new System.Threading.Timer(
            _ => handler(s, e), null, dueTime, Timeout.InfiniteTimeSpan);
        var previousTimer = Interlocked.Exchange(ref timer, newTimer);
        previousTimer?.Dispose();
    };
}

使用示例：

public event EventHandler<int> SomeEvent;

//...

this.SomeEvent += Throttle<int>((s, e) =>
{
    Console.WriteLine($"Received: {e}");
}, TimeSpan.FromSeconds(1.0));