c# - 使用 SetWindowsHookEx 设置的低级键盘 Hook 停止在 C# 中调用函数

Question

我正在创建一个程序来监控全局控制 iTunes 的按键。它还有一些 WinForms(用于显示轨道信息和编辑选项)。

低级键盘 Hook 在一段时间内效果很好。如果我刚启动该程序，键盘 Hook 已设置并且 iTunes 打开。然后我打开记事本，可以非常快速地键入大量内容，每一个笔划都被捕获， Hook 函数最多花费 30 毫秒(并且大部分时间 <10 毫秒)。 Hook 函数只是将事件添加到队列中，该队列由另一个线程处理。它使用自己的 Application.Run() 在自己的高优先级线程上运行。

但是，如果我开始在 iTunes 中执行操作(例如在我的程序中生成事件的几次播放/暂停点击)或在程序中(例如打开选项窗口)，则 Hook 函数将停止调用!即使从未使用过键盘(例如，启动，在 iTunes 中点击播放和暂停几次，然后按一个键)，也会发生这种情况。

钩子(Hook)没有被调用的原因不是因为钩子(Hook)函数花费了太多时间。

当我调用 UnhookWindowsHookEx 时，它总是返回 true，无论是否仍在调用 Hook 函数。

那么，可能是什么原因呢？

一个想法(尽管我没有证据或解决方案)是托管线程不再是正确的 native 线程。我在我的程序中使用了许多(托管)线程，并且我读到单个 native 线程可以运行许多托管线程并且托管线程可以更改正在运行它的 native 线程。 Hook 是否可能仍在生成消息但将它们发送到错误的线程？如果是这种情况，我该如何解决？

---

编辑:钩子(Hook)和回调

我的 KeyMonitor 的一个略微精简的完成版本。为了清楚起见，它被剥离了。我删除了一些实用程序(如 Key 枚举的大部分值和 Keys 类的许多函数，如 ToString() 和 FromString())以及一些错误处理。

大部分重要的东西都在 KeyMonitor 类中。 KeyMonitor.Start() 为消息启动一个线程，KeyMonitor.HookThread() 是该线程并为消息循环创建 Hook 以及 Application.Run()，KeyMonitor.KeyboardHookProc() 是回调函数，而 KeyMonitor. HookEventDispatchThread() 用于调度回调记录的事件。

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace KeyTest
{
    enum Key : int
    {
        Shift = 0x10, Ctrl, Alt,
        Left_Win = 0x5B, Right_Win,
        Left_Shift = 0xA0, Right_Shift, Left_Ctrl, Right_Ctrl, Left_Alt, Right_Alt,
    }

    class Keys
    {
        [DllImport("user32.dll")]
        private static extern int GetKeyboardState(byte[] pbKeyState);
        public const int Count = 256; // vkCode are from 1 to 254, but GetKeyboardState uses 0-255

        private readonly bool[] keys = new bool[Count];

        public Keys() { }

        private void DoModifier(Key x, Key l, Key r) { keys[(int)x] = keys[(int)l] || keys[(int)r]; }
        private void DoModifiers()
        {
            DoModifier(Key.Shift, Key.Left_Shift, Key.Right_Shift);
            DoModifier(Key.Ctrl, Key.Left_Ctrl, Key.Right_Ctrl);
            DoModifier(Key.Alt, Key.Left_Alt, Key.Right_Alt);
        }
        private void DoModifier(Key x, Key l, Key r, Key k) { if (k == l || k == r) keys[(int)x] = keys[(int)l] || keys[(int)r]; }
        private void DoModifiers(Key k)
        {
            DoModifier(Key.Shift, Key.Left_Shift, Key.Right_Shift, k);
            DoModifier(Key.Ctrl, Key.Left_Ctrl, Key.Right_Ctrl, k);
            DoModifier(Key.Alt, Key.Left_Alt, Key.Right_Alt, k);
        }

        public bool this[int i] { get { return this.keys[i]; } set { this.keys[i] = value; DoModifiers((Key)i); } }
        public bool this[Key k] { get { return this.keys[(int)k]; } set { this.keys[(int)k] = value; DoModifiers(k); } }

        public void LoadCurrentState()
        {
            byte[] keyState = new byte[Count];
            if (GetKeyboardState(keyState) != 0)
                for (int i = 0; i < Count; ++i)
                    keys[i] = (keyState[i] & 0x80) != 0;
            DoModifiers();
        }
    }

    static class KeyMonitor
    {
        #region Windows API
        private delegate int HookProc(int nCode, UIntPtr wParam, IntPtr lParam);

        [DllImport("user32.dll", SetLastError = true)]
        private static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, int dwThreadId);
        [DllImport("user32.dll", SetLastError = true)]
        private static extern int UnhookWindowsHookEx(int idHook);
        [DllImport("user32.dll")]
        private static extern int CallNextHookEx(int idHook, int nCode, UIntPtr wParam, IntPtr lParam);

        private const int WH_KEYBOARD_LL = 13;
        private readonly static UIntPtr WM_KEYDOWN = new UIntPtr(0x100), WM_SYSKEYDOWN = new UIntPtr(0x104);
        #endregion

        public static event KeyEventHandler OverridingKeyChange;
        public static event KeyEventHandler KeyChange;

        private struct KeyEventData { public int vk; public bool down; }

        private static int hook = 0;
        private static Thread dispatchThread = null, hookThread = null;
        private static Keys keys = new Keys();
        private static Queue<KeyEventData> queue = new Queue<KeyEventData>();

        private static void Enqueue(int vk, bool down)
        {
            lock (queue)
            {
                queue.Enqueue(new KeyEventData() { vk = vk, down = down });
                Monitor.Pulse(queue);
            }
        }
        public static Keys Keys { get { return keys; } }

        public static void Start()
        {
            if (hook == 0)
            {
                dispatchThread = new Thread(HookEventDispatchThread);
                hookThread = new Thread(HookThread);
                hookThread.Priority = ThreadPriority.Highest;
                dispatchThread.Start();
                hookThread.Start();
            }
        }

        public static void Stop()
        {
            if (hook != 0)
            {
                // Minimal cleanup...
                UnhookWindowsHookEx(hook);
                Application.Exit();
                dispatchThread.Interrupt();
            }
        }

        private static void HookThread()
        {
            hook = SetWindowsHookEx(WH_KEYBOARD_LL, new HookProc(KeyboardHookProc), IntPtr.Zero, 0);
            if (hook == 0) { /* Handle error */ }
            keys.LoadCurrentState();
            Application.Run();
        }

        private static int KeyboardHookProc(int nCode, UIntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0)
                Enqueue(Marshal.ReadInt32(lParam), wParam == WM_SYSKEYDOWN || wParam == WM_KEYDOWN);
            return CallNextHookEx(hook, nCode, wParam, lParam);
        }

        private static void HookEventDispatchThread()
        {
            for (; ; )
            {
                KeyEventData data;
                lock (queue)
                {
                    if (queue.Count == 0)
                        try
                        {
                            Monitor.Wait(queue);
                        }
                        catch (ThreadInterruptedException) { return; }
                    data = queue.Dequeue();
                }
                if (data.vk == -1)
                {
                    // Done!
                    keys = new Keys();
                    queue.Clear();
                    return;
                }
                else if (keys[data.vk] == data.down)
                    continue;

                keys[data.vk] = data.down;
                KeyEventArgs e = new KeyEventArgs((System.Windows.Forms.Keys)data.vk);
                if (OverridingKeyChange != null) OverridingKeyChange(null, e);
                if (!e.Handled && KeyChange != null) KeyChange(null, e);
            }
        }
    }

}

Answer 1

您需要将委托(delegate)保存到一个变量中，该变量将在您的应用程序期间继续存在。否则，委托(delegate)将被垃圾回收(奇怪的是应用程序没有崩溃!)。

static HookProc hookProc;
...

hookProc = new HookProc(KeyboardHookProc);
hook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, IntPtr.Zero, 0);