Is this a proper use of DoEvents? - Sample Project Included

Question

I'm using the first code block to execute a low-level mouse hook on a separate thread. It actually works like this (believe it or not) because the act of subscribing initializes the hook. And with a hook I need to be able to block the method calling an event so that I can set a value to alter its course of execution. This is the reason why I can't simply off-load the event handler to another thread.

My problems is, even though this works, is there another way that can avoid DoEvents?

Is it possible that DoEvents only applies to events on its own thread or does this call affect my GUI thread? It does not appear to affect my GUI at all as far as I can tell.

Note: Without the call to Sleep the CPU will increase significantly.
Note: Without DoEvents the hook messages build up and force the OS to disconnect the hook.

EDIT: I created a sample project so you guys can test this. The app will start a mouse hook on a separate thread and capture a mouse right-click and let you know it did so via a message box. You can get that project using the below link.

The sample shows that you can block the GUI thread and still handle the hook without issues which confirms that the hook is on its own thread.

https://github.com/mzomparelli/Threaded-Low-Level-Mouse-Hook-Example

I am now starting to think that this is a valid use of DoEvents despite the many claims that DoEvents is always bad.

private static bool blnStopMouseHook = false;
        public static void StartMouseHook()
        {
            if (MouseHook == null)
            {
                blnStopMouseHook = false;
                MouseHook = new Thread(new ThreadStart(() => { MouseHookThread(); }));
                MouseHook.SetApartmentState(ApartmentState.STA);
                MouseHook.Start();
            }
        }

        public static void StopMouseHook()
        {
            blnStopMouseHook = true;
            MouseHook.Join();
            MouseHook = null;
        }

        private static void MouseHookThread()
        {
            HookManager.MouseWheel += HookHandlers.HookManagerOnMouseWheel;
            HookManager.MouseClickExt += HookHandlers.HookManagerOnMouseClickExt;
            do
            {
                System.Threading.Thread.Sleep(1);
                Application.DoEvents();
            } while (blnStopMouseHook == false);

            HookManager.MouseWheel -= HookHandlers.HookManagerOnMouseWheel;
            HookManager.MouseClickExt -= HookHandlers.HookManagerOnMouseClickExt;

        }

Below is a snippet of my HookProc which creates the event HookManagerOnMouseWheel

private static int MouseHookProc(int nCode, int wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                //Marshall the data from callback.
                MouseLLHookStruct mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));

                switch (wParam)
                {
                    case WM_MOUSEWHEEL:
                        mouseDelta = (short)((mouseHookStruct.MouseData >> 16) & 0xffff);
                       break;
                }

                //generate event 
                MouseEventExtArgs e = new MouseEventExtArgs(
                                                   button,
                                                   clickCount,
                                                   mouseHookStruct.Point.X,
                                                   mouseHookStruct.Point.Y,
                                                   mouseDelta);



                //Wheel was moved
                if (s_MouseWheel!=null && mouseDelta!=0)
                {
                    s_MouseWheel.Invoke(null, e);
                }



                //If someone listens to move and there was a change in coordinates raise move event

                if (e.Handled)
                {
                    return -1;
                }
            }

            //call next hook
            return CallNextHookEx(s_MouseHookHandle, nCode, wParam, lParam);
        }

This is my event handler.

public static void HookManagerOnMouseWheel(object sender, MouseEventExtArgs mouseEventArgs)
        {

            int iHotkey;
            int iHotkey2;
            string keyCombination = CurrentModifiers();
            string keyCombination2 = CurrentModifiers();

            if (Window.Taskbar().IsMouseOver() || Window.Taskbar2().IsMouseOver())
            {
                //Create combination string

                if (mouseEventArgs.Delta < 0)
                {
                    keyCombination = keyCombination + "+MOUSE-TASKBAR-SCROLL-DOWN";
                    keyCombination2 = keyCombination2 + "+MOUSE-ANYWHERE-SCROLL-DOWN";
                }
                else
                {
                    keyCombination = keyCombination + "+MOUSE-TASKBAR-SCROLL-UP";
                    keyCombination2 = keyCombination2 + "+MOUSE-ANYWHERE-SCROLL-UP";
                }

                iHotkey = GLOBALS.hotkeys.FindIndex(l => l.HotkeyString() == keyCombination);
                iHotkey2 = GLOBALS.hotkeys.FindIndex(l => l.HotkeyString() == keyCombination2);
                if (iHotkey >= 0)
                {
                    ExecuteAction(iHotkey);
                    mouseEventArgs.Handled = true;
                    return;
                }
                else if (iHotkey2 >= 0)
                {
                    ExecuteAction(iHotkey2);
                    mouseEventArgs.Handled = true;
                    return;
                }
            }

            if (mouseEventArgs.Delta < 0)
            {
                keyCombination = keyCombination + "+MOUSE-ANYWHERE-SCROLL-DOWN";
            }
            else
            {
                keyCombination = keyCombination + "+MOUSE-ANYWHERE-SCROLL-UP";
            }

            iHotkey = GLOBALS.hotkeys.FindIndex(l => l.HotkeyString() == keyCombination);
            if (iHotkey >= 0)
            {
                ExecuteAction(iHotkey);
                mouseEventArgs.Handled = true;
                return;
            }


        }

Answer 1

The trouble with multithreading is that there is no guarantee that the main thread won't send more events than the worker thread can handle, or that the worker thread will be "starved" by the lack of anything to do. That is why your code has those ugly Sleep and DoEvents calls.

What you need is a synchronization mechanism.

I would suggest in this case that you follow a producer-consumer pattern, which requires a queue. I'd recommend in this case you use a BlockingCollection for your queue.

A blocking collection will allow the main thread to add events to it and provides methods that allow the worker thread to take events from it. If there are no events, the collection will block the worker thread until one is available.

So first, declare a data structure for holding events:

struct Event 
{
    object sender;
    EventArgs e;
}

Then declare your queue:

private BlockingCollection<Event> _queue = new BlockingCollection<Event>();

In your main thread, handle your events with a normal event handler that adds to the queue:

private OnMouseAction(object sender, EventArgs e)
{
    _queue.Add(new Event {sender = sender, e = e});
}

And in your worker thread, just read the queue and act on it:

private void MouseHookWorker(CancellationToken token)
{
    try
    {
        while (!token.IsCancellationRequested)
        {
            var event = _queue.Take(token);
            ProcessEvent(event.sender, event.e);
        }
    }
    catch (OperationCanceledException ex)
    {
    }
}     

And implement the real work (whatever that is) in ProcessEvent.

To stop the worker thread, you can either signal the cancellation token, or simple stop the queue with _queue.CompleteAdding();

The CancellationToken is sort of optional, but probably a good idea. If you don't know how to use it, see this question.

Answer 2

With your existing code you are attaching the events on the newly created thread, but that doesn't mean that the new thread will handle the events. In fact it doesn't. Whatever thread that causes the event to be raised will go on to handle the event. That's why you need the DoEvents calls in your code.

You need a way to marshal the events to the background thread after the event is raised.

If I were you I'd use Microsoft's Reactive Framework (Rx) for this. Just NuGet "System.Reactive" for the main bits and "System.Reactive.Windows.Forms" for the WinForms bits, and "System.Reactive.Windows.Threading" for the WPF bits.

Then you can do things like this:

IObservable<EventPattern<MouseEventArgs>> mouseMoves =
        Observable
            .FromEventPattern<MouseEventHandler, MouseEventArgs>(
                h => this.MouseMove += h,
                h => this.MouseMove -= h);

IDisposable subscription =
    mouseMoves
        .ObserveOn(Scheduler.Default)
        .Do(ep =>
        {
            Console.WriteLine("Th" + Thread.CurrentThread.ManagedThreadId);
        })
        .ObserveOn(this)
        .Subscribe(ep =>
        {
            Console.WriteLine("UI" + Thread.CurrentThread.ManagedThreadId);
        });

Console.WriteLine("!" + Thread.CurrentThread.ManagedThreadId);

This code handles events, but pushes the event on to the a background thread with the .ObserveOn(Scheduler.Default) call.

In this case I've used Windows Forms, so the .ObserveOn(this) (with the this being the current form) pushes the call back to the UI thread.

So, when I run this code and move the mouse around on the form I get an output like this:

!1
Th4
Th4
UI1
UI1
Th4
UI1
Th4
UI1
Th4
UI1
Th4
UI1

It should be fairly clear to see that this code is correctly pushing the call to a background thread and then back to the UI.

No blocking occurs.

To detach the event handler just call subscription.Dispose();.

In my code I installed NuGet packages "System.Reactive" and "System.Reactive.Windows.Forms", and added these usings:

using System.Reactive;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
using System.Threading;

---

Try this code:

        IDisposable subscription =
        (
            from mm in mouseMoves
            let direction = mm.EventArgs.Delta < 0 ? "DOWN" : "UP"
            let keyCombination = CurrentModifiers() + "+MOUSE-ANYWHERE-SCROLL-" + direction
            let iHotkey = GLOBALS.hotkeys.FindIndex(l => l.HotkeyString() == keyCombination)
            where iHotkey >= 0
            select new { mm.EventArgs, iHotkey }
        )
            .Do(x => x.EventArgs.Handled = true)
            .ObserveOn(Scheduler.Default)
            .Subscribe(x => ExecuteAction(x.iHotkey));

This will block the incoming caller and will set the EventArgs.Handled = true asap, before pushing the call to ExecuteAction(x.iHotkey) on a different thread.