A Better Way to Implement a WaitForMouseUp() Function?

Question

I needed a small function that will wait for the left mous button to be released, and will not be based on the MouseUp event.

In many cases when we need this, we simply write an event handler for the MouseUp event.
It's simple, and it works.

There are however cases, where using the MouseUp event will not be useful,
such as when we are already in another (different) event handler,
and the left mouse button might be pressed when this event handler is called, and we need to wait for it to be released. (the goal is to have a single flow of code, and not have to split it between several places which might already be occupied with another code)

I implemented it this way:

public void WaitForMouseUp()
{
    while( (Control.MouseButtons&MouseButtons.Left)!=0 )
        Application.DoEvents();
}

It works,
you can use it for example when you are in the event handler for the Control.Enter event,
and if the control was entered via the mouse, then this function will block until the mouse button is released.

I only worry about one thing:
I am using Application.DoEvents() there, and I wonder if there another way instead of using Application.DoEvents(). (Application.DoEvents(); has disadvantages of possible reentrancy, and so, so for this reason I try to minimize using it, whenever possible)

Anyone has an idea with what I can substitute the Application.DoEvents() part?

Answer 1

Here's an awesome way to do what you're asking. Use Microsoft's Reactive Extensions to make a single line of code do everything you want.

The reactive extensions provide a whole lot of operators that can be applied to events.

So first some basic observables that directly relate to normal control events:

        var mouseEnters =
            Observable
                .FromEventPattern(
                    h => button1.MouseEnter += h,
                    h => button1.MouseEnter -= h);

        var mouseLeaves =
            Observable
                .FromEventPattern(
                    h => button1.MouseLeave += h,
                    h => button1.MouseLeave -= h);

        var mouseUps =
            Observable
                .FromEventPattern<MouseEventHandler, MouseEventArgs>(
                    h => button1.MouseUp += h,
                    h => button1.MouseUp -= h);

Now we need a query that will fire only once when the mouse up occurs, but only if the mouse has entered the button1, but only before it leaves.

        var query =
            mouseEnters
                .Select(me => mouseUps.Take(1).TakeUntil(mouseLeaves))
                .Switch();

Now to subscribe to the event to be able to handle it:

        var subscription =
            query
                .Subscribe(ep =>
                {
                    /*
                        this code runs for the first mouse up only
                        after each mouse enter on `button1`
                        unless the mouse leaves `button1`
                    */
                });

It now because very simple to unsubscribe as the type of subscription is IDisposable. So you simply call subscription.Dispose();.

Just NuGet "Rx-WinForms" to get the bits for your project.

Answer 2

In fact what @Kai Brummund is suggesting is a variation of my answer to Force loop to wait for an event. Adjusting the code from there for MouseUp is simple as

public static class Utils
{
    public static Task WhenMouseUp(this Control control)
    {
        var tcs = new TaskCompletionSource<object>();
        MouseEventHandler onMouseUp = null;
        onMouseUp = (sender, e) =>
        {
            control.MouseUp -= onMouseUp;
            tcs.TrySetResult(null);
        };
        control.MouseUp += onMouseUp;
        return tcs.Task;
    }
}

and the usage is

Control c = ...;
await c.WhenMouseUp();

The same technique can be used for any event.

Answer 3

If You wan't to write a flow within a single method, you can make an awaitable using a TaskCompletionSource.

Your flow:

await MouseUp();

...

private Task MouseUp() {
  _tcs = new TaskCompletionSource();
  return _tcs.Task;
}

public ... OnMouseUpEvent() {
  _tcs?.SetResult(true);
}

Sorry for Pseudo code, will update this once I get something other than a mobile.

OT: Commenters: Think outside of the Box!

Answer 4

I needed a small function that will wait for the mouse's left button to be released.

No you don't. WinForms GUI programming is event driven, asynchronous. You should use the MouseUp event to detect the mouse button's release. This does mean that you need to implement your logic using state based asynchronous techniques, rather than the synchronous model that you crave.