只要没有触发其他事件，就等待事件

Question

I have an async method where I would like to block execution until 2 seconds after the OnLeave event of a control is fired, but only if the OnEnter event is not fired in the meantime.

In other words, if the OnLeave event is fired and then OnEnter fires 1 sec after, it should wait for another OnLeave + another 2 seconds without the OnEnter firing again before returning back to my method.

This should also implement a timeout and I looked at using a Task.WaitAll() with a timeout, but just not quite sure how to do the first part because of the dependency on both events.

Can anyone provide some suggestions?

Answer 1

Try this:

public class Control {
    public EventHandler OnEnter;
    public EventHandler OnLeave;

    public void TriggerEnter() {
        if (OnEnter != null) {
            OnEnter(null, EventArgs.Empty);
        }
    }

    public void TriggerLeave() {
        if (OnLeave != null) {
            OnLeave(null, EventArgs.Empty);
        }
    }
}

class Program {
    public static EventHandler OnBufferedEvent;

    static void Main(string[] args) {
        bool hasEntered = false;
        Timer timer = new Timer(2000);
        OnBufferedEvent += (sender, eventArgs) => Console.WriteLine("My buffered event has fired");

        timer.Elapsed += (sender, e) =>{
            if (!hasEntered) {
                if (OnBufferedEvent != null) {
                    OnBufferedEvent(null, EventArgs.Empty);
                }
            }
        };

        Control control = new Control {
            OnEnter = (sender, eventArgs) => {
                hasEntered = true;
                Console.WriteLine("On enter event has fired");
            },
            OnLeave = (sender, eventArgs) => {
                hasEntered = false;
                timer.Start();
                Console.WriteLine("On leave event has fired");
            }
        };

        control.TriggerLeave();
        Thread.Sleep(1000);
        control.TriggerEnter();
        Thread.Sleep(100);
        control.TriggerLeave();
        Thread.Sleep(2500);
    }
}

Another, more exotic solution, would be using Rx to buffer events and do observation logic on them.

This link provides some more explanations but you will have to create observable collections out of both Enter and Leave events and mix them up together. Not a trivial task.