Delay the execution of a code

Question

I'm registering to an event of a UserControl, this event is thrown every time I move a scrollbar(meaning that we will receive a lot of events). Unfortunately, we have no events to be informed when the user finished to use the scrollbar(== MouseUp).

We decided to implement a mechanism to update our models only once we didn't receive any new notifications from the scrollbar since 300ms.

I can see how to do this with a Timer and reseting the timer everytime the ScrollBar event is comming.

I was wondering if there was a way to do it with Linq and Delay?

private Action _actionOnMoved;

private void OnScrollBarMoved(object sender, EventArgs args){

}

EDIT

I've read the potentially duplicated answer, but Throttling is not the same thing that what I'm asking. In my case, as far I've event coming in less than the specified time, I don't want to do anything(not even the first one), since applying this change will take 3-5 seconds to be retrieved.

So what differs:

• In the given link, the first call is executed no matter what
• In my case, if a call is made within the delay, the call should still be executed AFTER the delay

By example, if this event is triggered every 100ms, and that the delay is 300ms, I expect to never have my method called.

Answer 1

You can wrap event handler into following

object _lock = new object();

SomeEvent += (s, e) =>
{
    lock(_lock)
    {
        Monitor.PulseAll(_lock); // pulse any (if any) awaiting events
        if(!Monitor.Wait(_lock, 5000)) // delay
        {
            ... // call event handler
                // we are here if timeout is expired
        }
    }
}

Untested, but here is the idea: when event is received you start waiting for either pulse or timeout. If pulse come (means another event was received), then you simply exit. If timeout occurs (means no another event happens), then you call event handler.

Note: it's not asynchronous, event caller (the call or SomeEvent) will be blocked for duration of delay. You may need to wrap lock into Task.Run:

SomeEvent += (s, e) => Task.Run(() =>
{
    ... // the rest of code
}

but that would rise event handler in some other thread, so you may have to dispatch (invoke) into thread you need.

Answer 2

Use a while loop and ThreadPool to monitor the event.

class MyForm : Form {
    private volatile bool mouseWheelHandling = false;
    private UserControl userControl;

    public void Form_Load(){
        // userControl.Scroll 
        userControl.MouseWheel += (s, a) => {
            if(!mouseWheelHandling) { // capture MouseWheel and Scroll events, only handle 1 times.
                mouseWheelHandling = true;
                ThreadPool.QueueUserWorkItem(_=>{
                    var horizontalScroll = userControl.HorizontalScroll.Value;
                    while(true) {
                        Thread.Sleep(100);
                        if(horizontalScroll == userControl.HorizontalScroll.Value) {
                            // Control.Invoke to handle cross-thread action
                            // do action
                            mouseWheelHandling = false; // reset the flag
                            break;
                        }
                        horizontalScroll = userControl.HorizontalScroll.Value;
                    }
                });
            }
        }
    }
}

Answer 3

I did ended by using a modified version of Sinatr answer:

public static EventHandler CreateDelayedEventHandler(EventHandler<EventArgs> handler, TimeSpan delay)
{
    object lockObject = new object();

    return (s, e) =>
    {
        Task.Run(() =>
        {
            lock (lockObject)
            {
                Monitor.PulseAll(lockObject);
                if (!Monitor.Wait(lockObject, delay))
                {
                    handler(s, e);
                }
            }
        });
    };
}

The only doubt I've now is how many task will be created to just potentially do nothing.