WPF中Windows键盘钩子引发System.ExecutionEngineException的规避咨询

问题描述 #

我用Windows钩子实现全局热键功能，功能正常，但快速连续按下多键时，WPF窗口常抛出System.ExecutionEngineException。排查发现是钩子破坏消息循环导致的，请问有哪些避免方法？

补充说明：我了解RegisterHotKey函数，但需要在热键激活时终止按键事件，防止其他程序触发相同热键。

现有代码实现 #

钩子设置 #

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook,
    LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
    IntPtr wParam, IntPtr lParam);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);

private static IntPtr SetHook(LowLevelKeyboardProc proc)
{
    using (Process curProcess = Process.GetCurrentProcess())
    using (ProcessModule curModule = curProcess.MainModule)
    {
        return SetWindowsHookEx(WH_KEYBOARD_LL, proc,
            GetModuleHandle(curModule.ModuleName), 0);
    }
}

钩子回调 #

private static IntPtr HookCallback(
    int nCode, IntPtr wParam, IntPtr lParam)
{
    bool isKeyProcessed = false;
    try
    {
        if (nCode >= 0 && (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN))
        {
            int vkCode = Marshal.ReadInt32(lParam);
            isKeyProcessed = KeyDown?.Invoke((Keys)vkCode) ?? false;
        }
        else if (nCode >= 0 && (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP))
        {
            int vkCode = Marshal.ReadInt32(lParam);
        
            isKeyProcessed = KeyUp?.Invoke((Keys)vkCode) ?? false;
        }
    }
    catch (Exception ex)
    {
        isKeyProcessed = false;
        try
        {
            ExceptionHappend?.Invoke(ex);
        }
        catch { }
    }

    if (!isKeyProcessed)
        return CallNextHookEx(_hookID, nCode, wParam, lParam);
    else
        return (IntPtr)1;
}

按键事件处理程序 #

public bool HandleKeyDown(Keys key)
{
    lock (_lock)
    {
        currentCombo.Keys.Add(key);
        if (hotkeys.ContainsKey(currentCombo))
        {
            RunHandler(hotkeys[currentCombo]);
            currentCombo.Keys.Clear();
            return true;
        }
        return false;
    }
}

private void RunHandler(Action handler)
{
    _runningActions = _runningActions.Where(x=>x.Status == TaskStatus.Running).ToList();
    var task = new Task(handler);
    task.Start();
    _runningActions.Add(task);
}

热键处理示例 #

public void ShowWorkedQ()
{
    Dispatcher.Invoke(new Action(() =>
    {
        OutLabel.Text = "Pressed Alt+Q";
    }));
}

解决方法 #

1. 剥离钩子回调的耗时逻辑 #

LowLevel键盘钩子的回调运行在系统消息队列的同步上下文中，任何耗时操作都会阻塞系统消息循环，引发异常。需将热键匹配、任务启动等逻辑移到后台线程处理：

// 线程安全队列缓存按键事件
private static ConcurrentQueue<(int nCode, IntPtr wParam, IntPtr lParam)> _keyEventQueue = new ConcurrentQueue<(int, IntPtr, IntPtr)>();
private static bool _isProcessing = true;

// 初始化时启动后台处理线程
public void InitializeHook()
{
    _hookID = SetHook(HookCallback);
    Task.Run(ProcessKeyEvents);
}

private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
    try
    {
        if (nCode >= 0)
        {
            // 仅将事件存入队列，快速返回
            _keyEventQueue.Enqueue((nCode, wParam, lParam));
        }
    }
    catch (Exception ex)
    {
        ExceptionHappend?.Invoke(ex);
    }
    // 必须先调用下一个钩子，避免阻塞系统消息流
    return CallNextHookEx(_hookID, nCode, wParam, lParam);
}

// 后台线程处理按键事件
private void ProcessKeyEvents()
{
    while (_isProcessing)
    {
        if (_keyEventQueue.TryDequeue(out var evt))
        {
            var (nCode, wParam, lParam) = evt;
            bool isProcessed = false;

            if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                isProcessed = KeyDown?.Invoke((Keys)vkCode) ?? false;
            }
            else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                isProcessed = KeyUp?.Invoke((Keys)vkCode) ?? false;
            }
        }
        Thread.Sleep(1); // 避免空转占用CPU
    }
}

2. 异步更新UI避免阻塞 #

原代码中Dispatcher.Invoke是同步调用，会阻塞触发线程（可能是钩子上下文），改用异步调用：

public void ShowWorkedQ()
{
    Dispatcher.BeginInvoke(new Action(() =>
    {
        OutLabel.Text = "Pressed Alt+Q";
    }));
}

3. 修复组合键处理的线程安全问题 #

使用不可变对象处理组合键，避免集合修改时的线程冲突：

// 自定义不可变组合键类型，重写Equals和GetHashCode
public class KeyCombo : IEquatable<KeyCombo>
{
    public IReadOnlyCollection<Keys> Keys { get; }

    public KeyCombo(IEnumerable<Keys> keys)
    {
        Keys = keys.OrderBy(k => k).ToList().AsReadOnly();
    }

    public bool Equals(KeyCombo other)
    {
        if (other is null) return false;
        return Keys.SequenceEqual(other.Keys);
    }

    public override bool Equals(object obj) => Equals(obj as KeyCombo);

    public override int GetHashCode()
    {
        int hash = 17;
        foreach (var key in Keys)
        {
            hash = hash * 31 + key.GetHashCode();
        }
        return hash;
    }
}

// 修改HandleKeyDown方法
public bool HandleKeyDown(Keys key)
{
    lock (_lock)
    {
        var newCombo = new KeyCombo(currentCombo.Keys.Concat(new[] { key }));
        if (hotkeys.ContainsKey(newCombo))
        {
            RunHandler(hotkeys[newCombo]);
            currentCombo = new KeyCombo(Enumerable.Empty<Keys>());
            return true;
        }
        currentCombo = newCombo;
        return false;
    }
}

4. 确保钩子正确卸载 #

在窗口关闭或程序退出时，必须卸载钩子并停止后台线程：

protected override void OnClosed(EventArgs e)
{
    _isProcessing = false;
    UnhookWindowsHookEx(_hookID);
    base.OnClosed(e);
}

5. 优化任务管理逻辑 #

原RunHandler中清理任务列表的方式效率低，改用ConcurrentBag或定期清理：

private ConcurrentBag<Task> _runningActions = new ConcurrentBag<Task>();

private void RunHandler(Action handler)
{
    // 定期清理已完成的任务
    _runningActions = new ConcurrentBag<Task>(_runningActions.Where(t => !t.IsCompleted));
    var task = Task.Run(handler);
    _runningActions.Add(task);
}

内容的提问来源于stack exchange，提问作者Ksnadr Renderon