如何降低连续触发事件的事件处理频率

你可以利用 Reactive Extensions 这样做:

void Main()
{
    var generator = new EventGenerator();
    var observable = Observable.FromEventPattern<EventHandler<bool>, bool>(
                h => generator.MyEvent += h,
                h => generator.MyEvent -= h);

    observable
        .Throttle(TimeSpan.FromSeconds(1))
        .Subscribe(s =>
        {
            Console.WriteLine("doing something");
        });

    // simulate rapid firing event
    for(int i = 0; i <= 100; i++)
        generator.RaiseEvent(); 

    // when no longer interested, dispose the subscription  
    subscription.Dispose(); 
}

public class EventGenerator
{
    public event EventHandler<bool> MyEvent;

    public void RaiseEvent()
    {
        if (MyEvent != null)
        {
            MyEvent(this, false);
        }
    }
}

这个 Throttle 上面编码的运算符将允许值(事件)每秒变为真。

所以在上面的代码示例中, 做某事 即使事件被多次激发,也只能打印一次(一秒钟后)。

编辑
顺便说一下,绿线的原因是你的任务没有等待。要修复它,请将代码更改为:

protected async void DummyEventHandler(object sender, bool arg)
{
    TotalCallActual++;
    await LargeCPUBoundTask(); // there is no more green underline here
}

不幸的是,这仍然不能解决您的问题,因为无法等待事件,因此如果事件在 LargeCPUBoundTask 仍在运行另一个呼叫 大型公共场所任务 如果你明白我的意思的话,工作是重叠的。换句话说,这就是代码不起作用的原因。

我将使用计时器事件处理程序而不是您的dummeyEventHandler 只需调整定时器的频率,单位为毫秒秒,就可以了。您可以通过代码创建计时器,而不必将其作为控件添加到窗体中。我认为它在公共控件库中。

希望这有帮助。祝你好运。

我花了更多的时间思考这个问题,我用我的第一个解决方案所做的假设是,事件是连续不断地发生的,当它可能只是在一段时间内触发一部分时间,然后在 真实的 问题。

在这种情况下,CPU绑定的任务只会在第一个事件触发时发生,然后如果事件在该CPU绑定的任务完成之前完成触发,则不会处理其余的事件。但你不想处理所有的问题,只想处理“最后一个”问题(不一定是实际的最后一个问题,只需要再处理一个“清理”问题)。

因此,我更新了我的答案,将出现频繁但间歇的用例(即事件突发然后安静)包括在内,正确的事情会发生,最终运行CPU绑定任务(但每次运行的CPU绑定任务仍不超过1个)。

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        Sender s = new Sender();
        using (Listener l = new Listener(s))
        {
            s.BeginDemonstration();
        }
    }
}

class Sender
{
    const int ATTEMPTED_CALLS = 1000000;

    internal EventHandler frequencyReducedHandler;
    internal int actualCalls = 0;
    internal int ignoredCalls = 0;

    Task[] tasks = new Task[ATTEMPTED_CALLS];

    internal void BeginDemonstration()
    {
        int attemptedCalls;
        for (attemptedCalls = 0; attemptedCalls < ATTEMPTED_CALLS; attemptedCalls++)
        {
            tasks[attemptedCalls] = Task.Run(() => frequencyReducedHandler.Invoke(this, EventArgs.Empty));
            //frequencyReducedHandler?.BeginInvoke(this, EventArgs.Empty, null, null);
        }
        if (tasks[0] != null)
        {
            Task.WaitAll(tasks, Timeout.Infinite);
        }
        Console.WriteLine($"Attempted: {attemptedCalls}\tActual: {actualCalls}\tIgnored: {ignoredCalls}");
        Console.ReadKey();
    }
}

class Listener : IDisposable
{
    enum State
    {
        Waiting,
        Running,
        Queued
    }

    private readonly AutoResetEvent m_SingleEntry = new AutoResetEvent(true);
    private readonly Sender m_Sender;

    private int m_CurrentState = (int)State.Waiting;

    internal Listener(Sender sender)
    {
        m_Sender = sender;
        m_Sender.frequencyReducedHandler += Handler;
    }

    private async void Handler(object sender, EventArgs args)
    {
        int state = Interlocked.Increment(ref m_CurrentState);
        try
        {
            if (state <= (int)State.Queued) // Previous state was WAITING or RUNNING
            {
                // Ensure only one run at a time
                m_SingleEntry.WaitOne();
                try
                {
                    // Only one thread at a time here so
                    // no need for Interlocked.Increment
                    m_Sender.actualCalls++;
                    // Execute CPU intensive task
                    await Task.Delay(500);
                }
                finally
                {
                    // Allow a waiting thread to proceed
                    m_SingleEntry.Set();
                }
            }
            else
            {
                Interlocked.Increment(ref m_Sender.ignoredCalls);
            }
        }
        finally
        {
            Interlocked.Decrement(ref m_CurrentState);
        }
    }

    public void Dispose()
    {
        m_SingleEntry?.Dispose();
    }
}