Comment réduire la fréquence de gestion des événements déclenchés en continu

J'utiliserais le gestionnaire d'événements timer au lieu de votre DummyEventHandler Ajustez simplement la fréquence en millisecondes de la minuterie et ce sera tout. Vous pouvez créer un minuteur via un code sans l'ajouter à un formulaire en tant que contrôle. Je pense que c'est dans les contrôles communs lib.

J'espère que cela vous aidera. Bonne chance.

Pour ce faire, vous pouvez utiliser les extensions réactives :

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

L'opérateur Throttle comme codé ci-dessus permettra à une valeur (événement) de devenir vraie toutes les secondes.

Ainsi, dans l'exemple de code ci-dessus, le texte faire quelque chose ne sera imprimé qu'une seule fois (après une seconde) même pendant l'événement est déclenché plusieurs fois.

Modifier
À propos, la raison de la ligne verte est que votre tâche n'est pas attendue. Pour résoudre ce problème, modifiez le code en:

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);
        }
    }
}

Malheureusement, cela ne résoudra toujours pas votre problème car un événement ne peut pas être attendu, donc si l'événement est à nouveau déclenché pendant LargeCPUBoundTask exécute toujours un autre appel à LargeCPUBoundTask sera effectué afin que le travail se chevauche si vous comprenez ce que je veux dire. En d'autres termes, c'est pourquoi votre code ne fonctionne pas.

J'ai passé un peu plus de temps à réfléchir à ce problème et l'hypothèse que j'ai faite avec ma première solution était que l'événement se déclenche continuellement, alors qu'il pourrait simplement se déclencher une partie du temps pendant un moment, puis s'arrêter dans le problème réel.

Dans des cas comme celui-ci, la tâche liée au processeur ne se produirait que lors du premier déclenchement d'événement, puis si les événements se terminent avant la fin de cette tâche liée au processeur, les événements restants ne seront pas traités. Mais vous ne voudriez pas les gérer tous, juste le "dernier" (pas nécessairement le dernier, juste un de plus pour s'occuper du "nettoyage").

Donc, j'ai a mis à jour ma réponse pour inclure le cas d'utilisation où il y a des cas d'utilisation fréquents mais intermittents (c'est-à-dire des rafales d'événements puis silencieux), la bonne chose se produirait et une exécution finale de la tâche liée au processeur se produirait (mais toujours pas plus d'une tâche liée au processeur en cours d'exécution à une fois).

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();
    }
}