c# - Hook 键盘复制输入(c#/xna)

Question

我在我的 XNA 项目中使用了键盘钩子(Hook)(任何使用 XNA 的人都知道内置键盘类对于“文本框”样式的输入是多么无用。

在引入表单之前，它非常适合在 XNA 项目中使用。如果我尝试在项目中实现任何表单，无论是自定义表单，还是 OpenFileDialog，表单文本框中的任何按键都会被加倍，从而几乎无法进行输入。

有谁知道如何阻止消息两次到达表单？也许当我收到消息时丢弃它？也许有更好的解决方案？或者也许这只是一些无法完成的事情。

感谢任何帮助。

编辑:

下面是我正在使用的键盘 Hook 代码，对于任何寻找 XNA 键盘 Hook 的人来说可能都很熟悉，因为它似乎在我寻找它的任何地方都会出现。

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms; // This class exposes WinForms-style key events.

namespace FatLib.Controls
{
    class KeyboardHookInput : IDisposable
    {
        private string _buffer = "";
        private bool _backSpace = false;
        private bool _enterKey = false; // I added this to the original code

        public string Buffer
        {
            get { return _buffer; }
        }
        public bool BackSpace
        {
            get
            {
                return _backSpace;
            }
        }
        public bool EnterKey
        {
            get
            {
                return _enterKey;
            }
        }
        public void Reset()
        {
            _buffer = "";
            _backSpace = false;
            _enterKey = false;
        }

        public enum HookId
        {
            // Types of hook that can be installed using the SetWindwsHookEx function.
            WH_CALLWNDPROC = 4,
            WH_CALLWNDPROCRET = 12,
            WH_CBT = 5,
            WH_DEBUG = 9,
            WH_FOREGROUNDIDLE = 11,
            WH_GETMESSAGE = 3,
            WH_HARDWARE = 8,
            WH_JOURNALPLAYBACK = 1,
            WH_JOURNALRECORD = 0,
            WH_KEYBOARD = 2,
            WH_KEYBOARD_LL = 13,
            WH_MAX = 11,
            WH_MAXHOOK = WH_MAX,
            WH_MIN = -1,
            WH_MINHOOK = WH_MIN,
            WH_MOUSE_LL = 14,
            WH_MSGFILTER = -1,
            WH_SHELL = 10,
            WH_SYSMSGFILTER = 6,
        };
        public enum WindowMessage
        {
            // Window message types.
            WM_KEYDOWN = 0x100,
            WM_KEYUP = 0x101,
            WM_CHAR = 0x102,
        };

        // A delegate used to create a hook callback.
        public delegate int GetMsgProc(int nCode, int wParam, ref Message msg);

        /// <summary>
        /// Install an application-defined hook procedure into a hook chain.
        /// </summary>
        /// <param name="idHook">Specifies the type of hook procedure to be installed.</param>
        /// <param name="lpfn">Pointer to the hook procedure.</param>
        /// <param name="hmod">Handle to the DLL containing the hook procedure pointed to by the lpfn parameter.</param>
        /// <param name="dwThreadId">Specifies the identifier of the thread with which the hook procedure is to be associated.</param>
        /// <returns>If the function succeeds, the return value is the handle to the hook procedure. Otherwise returns 0.</returns>
        [DllImport("user32.dll", EntryPoint = "SetWindowsHookExA")]
        public static extern IntPtr SetWindowsHookEx(HookId idHook, GetMsgProc lpfn, IntPtr hmod, int dwThreadId);

        /// <summary>
        /// Removes a hook procedure installed in a hook chain by the SetWindowsHookEx function. 
        /// </summary>
        /// <param name="hHook">Handle to the hook to be removed. This parameter is a hook handle obtained by a previous call to SetWindowsHookEx.</param>
        /// <returns>If the function fails, the return value is zero. To get extended error information, call GetLastError.</returns>
        [DllImport("user32.dll")]
        public static extern int UnhookWindowsHookEx(IntPtr hHook);

        /// <summary>
        /// Passes the hook information to the next hook procedure in the current hook chain.
        /// </summary>
        /// <param name="hHook">Ignored.</param>
        /// <param name="ncode">Specifies the hook code passed to the current hook procedure.</param>
        /// <param name="wParam">Specifies the wParam value passed to the current hook procedure.</param>
        /// <param name="lParam">Specifies the lParam value passed to the current hook procedure.</param>
        /// <returns>This value is returned by the next hook procedure in the chain.</returns>
        [DllImport("user32.dll")]
        public static extern int CallNextHookEx(int hHook, int ncode, int wParam, ref Message lParam);

        /// <summary>
        /// Translates virtual-key messages into character messages.
        /// </summary>
        /// <param name="lpMsg">Pointer to an Message structure that contains message information retrieved from the calling thread's message queue.</param>
        /// <returns>If the message is translated (that is, a character message is posted to the thread's message queue), the return value is true.</returns>
        [DllImport("user32.dll")]
        public static extern bool TranslateMessage(ref Message lpMsg);


        /// <summary>
        /// Retrieves the thread identifier of the calling thread.
        /// </summary>
        /// <returns>The thread identifier of the calling thread.</returns>
        [DllImport("kernel32.dll")]
        public static extern int GetCurrentThreadId();

        // Handle for the created hook.
        private readonly IntPtr HookHandle;

        private readonly GetMsgProc ProcessMessagesCallback;

        public KeyboardHookInput()
        {
            // Create the delegate callback:
            this.ProcessMessagesCallback = new GetMsgProc(ProcessMessages);
            // Create the keyboard hook:
            this.HookHandle = SetWindowsHookEx(HookId.WH_KEYBOARD, this.ProcessMessagesCallback, IntPtr.Zero, GetCurrentThreadId());
        }

        public void Dispose()
        {
            // Remove the hook.
            if (HookHandle != IntPtr.Zero) UnhookWindowsHookEx(HookHandle);
        }

        // comments found in this region are all from the original author: Darg.
        private int ProcessMessages(int nCode, int wParam, ref Message msg)
        {
            // Check if we must process this message (and whether it has been retrieved via GetMessage):
            if (nCode == 0 && wParam == 1)
            {
                // We need character input, so use TranslateMessage to generate WM_CHAR messages.
                TranslateMessage(ref msg);

                // If it's one of the keyboard-related messages, raise an event for it:
                switch ((WindowMessage)msg.Msg)
                {
                    case WindowMessage.WM_CHAR:
                        this.OnKeyPress(new KeyPressEventArgs((char)msg.WParam));
                        break;
                    case WindowMessage.WM_KEYDOWN:
                        this.OnKeyDown(new KeyEventArgs((Keys)msg.WParam));
                        break;
                    case WindowMessage.WM_KEYUP:
                        this.OnKeyUp(new KeyEventArgs((Keys)msg.WParam));
                        break;
                }
            }
            // Call next hook in chain:
            return CallNextHookEx(0, nCode, wParam, ref msg);
        }

        public event KeyEventHandler KeyUp;
        protected virtual void OnKeyUp(KeyEventArgs e)
        {
            if (KeyUp != null) KeyUp(this, e);
        }

        public event KeyEventHandler KeyDown;
        protected virtual void OnKeyDown(KeyEventArgs e)
        {
            if (KeyDown != null) KeyDown(this, e);
        }

        public event KeyPressEventHandler KeyPress;
        protected virtual void OnKeyPress(KeyPressEventArgs e)
        {
            if (KeyPress != null) KeyPress(this, e);
            if (e.KeyChar.GetHashCode().ToString() == "524296")
            {
                _backSpace = true;
            }
            else if (e.KeyChar == (char)Keys.Enter)
            {
                _enterKey = true;
            }
            else
            {
                _buffer += e.KeyChar;
            }
        }
    }
}

Answer 1

Windows Hook 是获取所有按键的一种非常糟糕的方式，并且绝对应该是最后的手段。

尝试安装 Message Filter到您的应用程序中，它可以监视发送到您的应用程序的所有键盘消息(WM_KEYPRESS、KEYUP、KEYDOWN 等)，而不会干扰其他应用程序。如果您愿意，过滤器还允许您阻止任何消息到达应用程序中的任何表单。