Я хочу записать сочетание клавиш в своем приложении и вызвать диалоговое окно, которое появится, если пользователь нажимает комбинацию клавиш даже вне приложения. Подобно Ctrl, Ctrl в Google Desktop Search для вызова диалогового окна поиска.
Я пробовал использовать некоторые модули клавиатуры, которые в основном используют взаимодействие Win32 для получения этого эффекта, но каждая реализация, которую я пробовал, до некоторой степени привязывает клавиатуру к тому, что вы начинаете получать странное поведение, когда приложение делает что-то интенсивное. Например, загрузка большого количества данных может привести к зависанию клавиатуры и мыши.
Я ищу легкое решение, которое позволило бы сделать это, не связывая клавиатуру и мышь.
.net
events
keyboard-hook
Джереми Эдвардс
источник
источник
Ответы:
Стивен Тауб написал отличную статью о реализации глобальных перехватчиков клавиатуры на C #:
using System; using System.Diagnostics; using System.Windows.Forms; using System.Runtime.InteropServices; class InterceptKeys { private const int WH_KEYBOARD_LL = 13; private const int WM_KEYDOWN = 0x0100; private static LowLevelKeyboardProc _proc = HookCallback; private static IntPtr _hookID = IntPtr.Zero; public static void Main() { _hookID = SetHook(_proc); Application.Run(); UnhookWindowsHookEx(_hookID); } 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 delegate IntPtr LowLevelKeyboardProc( int nCode, IntPtr wParam, IntPtr lParam); private static IntPtr HookCallback( int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) { int vkCode = Marshal.ReadInt32(lParam); Console.WriteLine((Keys)vkCode); } return CallNextHookEx(_hookID, nCode, wParam, lParam); } [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); }
источник
Вот мой код, который работает:
using System; using System.ComponentModel; using System.Diagnostics; using System.Runtime.InteropServices; namespace SnagFree.TrayApp.Core { class GlobalKeyboardHookEventArgs : HandledEventArgs { public GlobalKeyboardHook.KeyboardState KeyboardState { get; private set; } public GlobalKeyboardHook.LowLevelKeyboardInputEvent KeyboardData { get; private set; } public GlobalKeyboardHookEventArgs( GlobalKeyboardHook.LowLevelKeyboardInputEvent keyboardData, GlobalKeyboardHook.KeyboardState keyboardState) { KeyboardData = keyboardData; KeyboardState = keyboardState; } } //Based on https://gist.github.com/Stasonix class GlobalKeyboardHook : IDisposable { public event EventHandler<GlobalKeyboardHookEventArgs> KeyboardPressed; public GlobalKeyboardHook() { _windowsHookHandle = IntPtr.Zero; _user32LibraryHandle = IntPtr.Zero; _hookProc = LowLevelKeyboardProc; // we must keep alive _hookProc, because GC is not aware about SetWindowsHookEx behaviour. _user32LibraryHandle = LoadLibrary("User32"); if (_user32LibraryHandle == IntPtr.Zero) { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to load library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } _windowsHookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, _user32LibraryHandle, 0); if (_windowsHookHandle == IntPtr.Zero) { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to adjust keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } } protected virtual void Dispose(bool disposing) { if (disposing) { // because we can unhook only in the same thread, not in garbage collector thread if (_windowsHookHandle != IntPtr.Zero) { if (!UnhookWindowsHookEx(_windowsHookHandle)) { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to remove keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } _windowsHookHandle = IntPtr.Zero; // ReSharper disable once DelegateSubtraction _hookProc -= LowLevelKeyboardProc; } } if (_user32LibraryHandle != IntPtr.Zero) { if (!FreeLibrary(_user32LibraryHandle)) // reduces reference to library by 1. { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to unload library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } _user32LibraryHandle = IntPtr.Zero; } } ~GlobalKeyboardHook() { Dispose(false); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } private IntPtr _windowsHookHandle; private IntPtr _user32LibraryHandle; private HookProc _hookProc; delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam); [DllImport("kernel32.dll")] private static extern IntPtr LoadLibrary(string lpFileName); [DllImport("kernel32.dll", CharSet = CharSet.Auto)] private static extern bool FreeLibrary(IntPtr hModule); /// <summary> /// The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain. /// You would install a hook procedure to monitor the system for certain types of events. These events are /// associated either with a specific thread or with all threads in the same desktop as the calling thread. /// </summary> /// <param name="idHook">hook type</param> /// <param name="lpfn">hook procedure</param> /// <param name="hMod">handle to application instance</param> /// <param name="dwThreadId">thread identifier</param> /// <returns>If the function succeeds, the return value is the handle to the hook procedure.</returns> [DllImport("USER32", SetLastError = true)] static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, int dwThreadId); /// <summary> /// The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function. /// </summary> /// <param name="hhk">handle to hook procedure</param> /// <returns>If the function succeeds, the return value is true.</returns> [DllImport("USER32", SetLastError = true)] public static extern bool UnhookWindowsHookEx(IntPtr hHook); /// <summary> /// The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain. /// A hook procedure can call this function either before or after processing the hook information. /// </summary> /// <param name="hHook">handle to current hook</param> /// <param name="code">hook code passed to hook procedure</param> /// <param name="wParam">value passed to hook procedure</param> /// <param name="lParam">value passed to hook procedure</param> /// <returns>If the function succeeds, the return value is true.</returns> [DllImport("USER32", SetLastError = true)] static extern IntPtr CallNextHookEx(IntPtr hHook, int code, IntPtr wParam, IntPtr lParam); [StructLayout(LayoutKind.Sequential)] public struct LowLevelKeyboardInputEvent { /// <summary> /// A virtual-key code. The code must be a value in the range 1 to 254. /// </summary> public int VirtualCode; /// <summary> /// A hardware scan code for the key. /// </summary> public int HardwareScanCode; /// <summary> /// The extended-key flag, event-injected Flags, context code, and transition-state flag. This member is specified as follows. An application can use the following values to test the keystroke Flags. Testing LLKHF_INJECTED (bit 4) will tell you whether the event was injected. If it was, then testing LLKHF_LOWER_IL_INJECTED (bit 1) will tell you whether or not the event was injected from a process running at lower integrity level. /// </summary> public int Flags; /// <summary> /// The time stamp stamp for this message, equivalent to what GetMessageTime would return for this message. /// </summary> public int TimeStamp; /// <summary> /// Additional information associated with the message. /// </summary> public IntPtr AdditionalInformation; } public const int WH_KEYBOARD_LL = 13; //const int HC_ACTION = 0; public enum KeyboardState { KeyDown = 0x0100, KeyUp = 0x0101, SysKeyDown = 0x0104, SysKeyUp = 0x0105 } public const int VkSnapshot = 0x2c; //const int VkLwin = 0x5b; //const int VkRwin = 0x5c; //const int VkTab = 0x09; //const int VkEscape = 0x18; //const int VkControl = 0x11; const int KfAltdown = 0x2000; public const int LlkhfAltdown = (KfAltdown >> 8); public IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam) { bool fEatKeyStroke = false; var wparamTyped = wParam.ToInt32(); if (Enum.IsDefined(typeof(KeyboardState), wparamTyped)) { object o = Marshal.PtrToStructure(lParam, typeof(LowLevelKeyboardInputEvent)); LowLevelKeyboardInputEvent p = (LowLevelKeyboardInputEvent)o; var eventArguments = new GlobalKeyboardHookEventArgs(p, (KeyboardState)wparamTyped); EventHandler<GlobalKeyboardHookEventArgs> handler = KeyboardPressed; handler?.Invoke(this, eventArguments); fEatKeyStroke = eventArguments.Handled; } return fEatKeyStroke ? (IntPtr)1 : CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam); } } }
Применение:
using System; using System.Windows.Forms; namespace SnagFree.TrayApp.Core { internal class Controller : IDisposable { private GlobalKeyboardHook _globalKeyboardHook; public void SetupKeyboardHooks() { _globalKeyboardHook = new GlobalKeyboardHook(); _globalKeyboardHook.KeyboardPressed += OnKeyPressed; } private void OnKeyPressed(object sender, GlobalKeyboardHookEventArgs e) { //Debug.WriteLine(e.KeyboardData.VirtualCode); if (e.KeyboardData.VirtualCode != GlobalKeyboardHook.VkSnapshot) return; // seems, not needed in the life. //if (e.KeyboardState == GlobalKeyboardHook.KeyboardState.SysKeyDown && // e.KeyboardData.Flags == GlobalKeyboardHook.LlkhfAltdown) //{ // MessageBox.Show("Alt + Print Screen"); // e.Handled = true; //} //else if (e.KeyboardState == GlobalKeyboardHook.KeyboardState.KeyDown) { MessageBox.Show("Print Screen"); e.Handled = true; } } public void Dispose() { _globalKeyboardHook?.Dispose(); } } }
источник
public Keys Key { get { return (Keys)VirtualCode; } }
вLowLevelKeyboardInputEvent
. Это требует иметь дело с виртуальными кодами, которые каждый должен гуглить. Также: затем вы можете перейтиVkSnapshot
от ролиint
кKeys
и просто поместить ключ. Я пошел еще дальше и поставилpublic static Keys[] RegisteredKeys
. Приходит OnPressedif (!GlobalKeyboardHook.RegisteredKeys.Contains(e.KeyboardData.Key)) return;
. Вы могли точно просто предотвратить запуск Event;).Если глобальной горячей клавиши будет достаточно, то RegisterHotKey сделает свое дело
источник
По запросу dube выкладываю модифицированный вариант ответа Сергея Кучука .
Если вы хотите проверить мои изменения, ищите
// EDT
. Я прокомментировал большинство из них.Установка
class GlobalKeyboardHookEventArgs : HandledEventArgs { public GlobalKeyboardHook.KeyboardState KeyboardState { get; private set; } public GlobalKeyboardHook.LowLevelKeyboardInputEvent KeyboardData { get; private set; } public GlobalKeyboardHookEventArgs( GlobalKeyboardHook.LowLevelKeyboardInputEvent keyboardData, GlobalKeyboardHook.KeyboardState keyboardState) { KeyboardData = keyboardData; KeyboardState = keyboardState; } } //Based on https://gist.github.com/Stasonix class GlobalKeyboardHook : IDisposable { public event EventHandler<GlobalKeyboardHookEventArgs> KeyboardPressed; // EDT: Added an optional parameter (registeredKeys) that accepts keys to restict // the logging mechanism. /// <summary> /// /// </summary> /// <param name="registeredKeys">Keys that should trigger logging. Pass null for full logging.</param> public GlobalKeyboardHook(Keys[] registeredKeys = null) { RegisteredKeys = registeredKeys; _windowsHookHandle = IntPtr.Zero; _user32LibraryHandle = IntPtr.Zero; _hookProc = LowLevelKeyboardProc; // we must keep alive _hookProc, because GC is not aware about SetWindowsHookEx behaviour. _user32LibraryHandle = LoadLibrary("User32"); if (_user32LibraryHandle == IntPtr.Zero) { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to load library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } _windowsHookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, _user32LibraryHandle, 0); if (_windowsHookHandle == IntPtr.Zero) { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to adjust keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } } protected virtual void Dispose(bool disposing) { if (disposing) { // because we can unhook only in the same thread, not in garbage collector thread if (_windowsHookHandle != IntPtr.Zero) { if (!UnhookWindowsHookEx(_windowsHookHandle)) { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to remove keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } _windowsHookHandle = IntPtr.Zero; // ReSharper disable once DelegateSubtraction _hookProc -= LowLevelKeyboardProc; } } if (_user32LibraryHandle != IntPtr.Zero) { if (!FreeLibrary(_user32LibraryHandle)) // reduces reference to library by 1. { int errorCode = Marshal.GetLastWin32Error(); throw new Win32Exception(errorCode, $"Failed to unload library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}."); } _user32LibraryHandle = IntPtr.Zero; } } ~GlobalKeyboardHook() { Dispose(false); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } private IntPtr _windowsHookHandle; private IntPtr _user32LibraryHandle; private HookProc _hookProc; delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam); [DllImport("kernel32.dll")] private static extern IntPtr LoadLibrary(string lpFileName); [DllImport("kernel32.dll", CharSet = CharSet.Auto)] private static extern bool FreeLibrary(IntPtr hModule); /// <summary> /// The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain. /// You would install a hook procedure to monitor the system for certain types of events. These events are /// associated either with a specific thread or with all threads in the same desktop as the calling thread. /// </summary> /// <param name="idHook">hook type</param> /// <param name="lpfn">hook procedure</param> /// <param name="hMod">handle to application instance</param> /// <param name="dwThreadId">thread identifier</param> /// <returns>If the function succeeds, the return value is the handle to the hook procedure.</returns> [DllImport("USER32", SetLastError = true)] static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, int dwThreadId); /// <summary> /// The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function. /// </summary> /// <param name="hhk">handle to hook procedure</param> /// <returns>If the function succeeds, the return value is true.</returns> [DllImport("USER32", SetLastError = true)] public static extern bool UnhookWindowsHookEx(IntPtr hHook); /// <summary> /// The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain. /// A hook procedure can call this function either before or after processing the hook information. /// </summary> /// <param name="hHook">handle to current hook</param> /// <param name="code">hook code passed to hook procedure</param> /// <param name="wParam">value passed to hook procedure</param> /// <param name="lParam">value passed to hook procedure</param> /// <returns>If the function succeeds, the return value is true.</returns> [DllImport("USER32", SetLastError = true)] static extern IntPtr CallNextHookEx(IntPtr hHook, int code, IntPtr wParam, IntPtr lParam); [StructLayout(LayoutKind.Sequential)] public struct LowLevelKeyboardInputEvent { /// <summary> /// A virtual-key code. The code must be a value in the range 1 to 254. /// </summary> public int VirtualCode; // EDT: added a conversion from VirtualCode to Keys. /// <summary> /// The VirtualCode converted to typeof(Keys) for higher usability. /// </summary> public Keys Key { get { return (Keys)VirtualCode; } } /// <summary> /// A hardware scan code for the key. /// </summary> public int HardwareScanCode; /// <summary> /// The extended-key flag, event-injected Flags, context code, and transition-state flag. This member is specified as follows. An application can use the following values to test the keystroke Flags. Testing LLKHF_INJECTED (bit 4) will tell you whether the event was injected. If it was, then testing LLKHF_LOWER_IL_INJECTED (bit 1) will tell you whether or not the event was injected from a process running at lower integrity level. /// </summary> public int Flags; /// <summary> /// The time stamp stamp for this message, equivalent to what GetMessageTime would return for this message. /// </summary> public int TimeStamp; /// <summary> /// Additional information associated with the message. /// </summary> public IntPtr AdditionalInformation; } public const int WH_KEYBOARD_LL = 13; //const int HC_ACTION = 0; public enum KeyboardState { KeyDown = 0x0100, KeyUp = 0x0101, SysKeyDown = 0x0104, SysKeyUp = 0x0105 } // EDT: Replaced VkSnapshot(int) with RegisteredKeys(Keys[]) public static Keys[] RegisteredKeys; const int KfAltdown = 0x2000; public const int LlkhfAltdown = (KfAltdown >> 8); public IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam) { bool fEatKeyStroke = false; var wparamTyped = wParam.ToInt32(); if (Enum.IsDefined(typeof(KeyboardState), wparamTyped)) { object o = Marshal.PtrToStructure(lParam, typeof(LowLevelKeyboardInputEvent)); LowLevelKeyboardInputEvent p = (LowLevelKeyboardInputEvent)o; var eventArguments = new GlobalKeyboardHookEventArgs(p, (KeyboardState)wparamTyped); // EDT: Removed the comparison-logic from the usage-area so the user does not need to mess around with it. // Either the incoming key has to be part of RegisteredKeys (see constructor on top) or RegisterdKeys // has to be null for the event to get fired. var key = (Keys)p.VirtualCode; if (RegisteredKeys == null || RegisteredKeys.Contains(key)) { EventHandler<GlobalKeyboardHookEventArgs> handler = KeyboardPressed; handler?.Invoke(this, eventArguments); fEatKeyStroke = eventArguments.Handled; } } return fEatKeyStroke ? (IntPtr)1 : CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam); } }
Различия в использовании можно увидеть здесь
public partial class Form1 : Form { public Form1() { InitializeComponent(); } private GlobalKeyboardHook _globalKeyboardHook; private void buttonHook_Click(object sender, EventArgs e) { // Hooks only into specified Keys (here "A" and "B"). _globalKeyboardHook = new GlobalKeyboardHook(new Keys[] { Keys.A, Keys.B }); // Hooks into all keys. _globalKeyboardHook = new GlobalKeyboardHook(); _globalKeyboardHook.KeyboardPressed += OnKeyPressed; } private void OnKeyPressed(object sender, GlobalKeyboardHookEventArgs e) { // EDT: No need to filter for VkSnapshot anymore. This now gets handled // through the constructor of GlobalKeyboardHook(...). if (e.KeyboardState == GlobalKeyboardHook.KeyboardState.KeyDown) { // Now you can access both, the key and virtual code Keys loggedKey = e.KeyboardData.Key; int loggedVkCode = e.KeyboardData.VirtualCode; } } }
Спасибо Сергею Кучуку за его пост. Даже несмотря на то, что я упростил использование, этот исходный код был мне очень полезен.
источник
MessageBox
(для проверки того, что обработчик активен и работает):Managed Debugging Assistant 'CallbackOnCollectedDelegate' : 'A callback was made on a garbage collected delegate of type 'GlobalKeyboardHook+HookProc::Invoke'. This may cause application crashes, corruption and data loss. When passing delegates to unmanaged code, they must be kept alive by the managed application until it is guaranteed that they will never be called.'
Как я могу разрешить это исключение?LowLeveKeyboardProc()
:return fEatKeyStroke ? (IntPtr)1 : CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam);
Моя репутация слишком мала , чтобы комментарий, но относительно
CallbackOnCollectedDelegate
исключения, я модифицировалpublic void SetupKeyboardHooks()
в C4D в ответ выглядеть следующим образом :public void SetupKeyboardHooks(out object hookProc) { _globalKeyboardHook = new GlobalKeyboardHook(); _globalKeyboardHook.KeyboardPressed += OnKeyPressed; hookProc = _globalKeyboardHook.GcSafeHookProc; }
где
GcSafeHookProc
просто публичный геттер для_hookProc
OP_hookProc = LowLevelKeyboardProc; // we must keep alive _hookProc, because GC is not aware about SetWindowsHookEx behaviour.
и сохранил
hookProc
как частное поле в классе, вызывающемSetupKeyboardHooks(...)
, таким образом, сохраняя ссылку в действии, за исключением сборки мусора, больше никакихCallbackOnCollectedDelegate
исключений. Кажется, наличия этой дополнительной ссылки вGlobalKeyboardHook
классе недостаточно. Возможно, убедитесь, что эта ссылка также удаляется при закрытии вашего приложения.источник
private void buttonHook_Click(object sender, EventArgs e) { // Hooks only into specified Keys (here "A" and "B"). // (***) Use this constructor _globalKeyboardHook = new GlobalKeyboardHook(new Keys[] { Keys.A, Keys.B }); // Hooks into all keys. // (***) Or this - not both _globalKeyboardHook = new GlobalKeyboardHook(); _globalKeyboardHook.KeyboardPressed += OnKeyPressed; }
А потом работает нормально.
источник