使用 C# 设置全局热键

Posted 2023-03-17

【中文标题】使用 C# 设置全局热键

【英文标题】：Set global hotkeys using C#

【发布时间】：2018-12-21 18:56:02

【问题描述】：

当我的程序不在焦点时，我需要捕捉按键。 （即Ctrl+Alt+J）并在我的程序中触发一个事件。

到目前为止，我发现这个 dll 似乎是正确的路径"

[DllImport("user32.dll")]private static extern int RegisterHotKey(IntPtr hwnd, int id,int fsModifiers, int vk);

[DllImport("user32.dll")] private static extern int UnregisterHotKey(IntPtr hwnd, int id);

【问题讨论】：

查看pinvoke.net上的示例代码；)

见***.com/questions/81150/…

您可以查看我的帖子以获得 WPF 解决方案... [在此处输入链接描述][1] [1]：***.com/questions/48935/…

@Crash893 我知道这是一个老问题，感谢您更新答案，但请注意，如果您弄清楚了，您实际上可以发布自己问题的答案，而不是嵌入答案问题里面。干杯

【参考方案1】：

请注意，此代码不会触发控制台应用程序项目中的事件。您必须使用 WinForms 项目才能触发事件。

这是正确的代码：

public sealed  class KeyboardHook : IDisposable

    // Registers a hot key with Windows.
    [DllImport("user32.dll")]
    private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
    // Unregisters the hot key with Windows.
    [DllImport("user32.dll")]
    private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

    /// <summary>
    /// Represents the window that is used internally to get the messages.
    /// </summary>
    private class Window : NativeWindow, IDisposable
    
        private static int WM_HOTKEY = 0x0312;

        public Window()
        
            // create the handle for the window.
            this.CreateHandle(new CreateParams());
        

        /// <summary>
        /// Overridden to get the notifications.
        /// </summary>
        /// <param name="m"></param>
        protected override void WndProc(ref Message m)
        
            base.WndProc(ref m);

            // check if we got a hot key pressed.
            if (m.Msg == WM_HOTKEY)
            
                // get the keys.
                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
                ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);

                // invoke the event to notify the parent.
                if (KeyPressed != null)
                    KeyPressed(this, new KeyPressedEventArgs(modifier, key));
            
        

        public event EventHandler<KeyPressedEventArgs> KeyPressed;

        #region IDisposable Members

        public void Dispose()
        
            this.DestroyHandle();
        

        #endregion
    

    private Window _window = new Window();
    private int _currentId;

    public KeyboardHook()
    
        // register the event of the inner native window.
        _window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
        
            if (KeyPressed != null)
                KeyPressed(this, args);
        ;
    

    /// <summary>
    /// Registers a hot key in the system.
    /// </summary>
    /// <param name="modifier">The modifiers that are associated with the hot key.</param>
    /// <param name="key">The key itself that is associated with the hot key.</param>
    public void RegisterHotKey(ModifierKeys modifier, Keys key)
    
        // increment the counter.
        _currentId = _currentId + 1;

        // register the hot key.
        if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
            throw new InvalidOperationException("Couldn’t register the hot key.");
    

    /// <summary>
    /// A hot key has been pressed.
    /// </summary>
    public event EventHandler<KeyPressedEventArgs> KeyPressed;

    #region IDisposable Members

    public void Dispose()
    
        // unregister all the registered hot keys.
        for (int i = _currentId; i > 0; i--)
        
            UnregisterHotKey(_window.Handle, i);
        

        // dispose the inner native window.
        _window.Dispose();
    

    #endregion


/// <summary>
/// Event Args for the event that is fired after the hot key has been pressed.
/// </summary>
public class KeyPressedEventArgs : EventArgs

    private ModifierKeys _modifier;
    private Keys _key;

    internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
    
        _modifier = modifier;
        _key = key;
    

    public ModifierKeys Modifier
    
        get  return _modifier; 
    

    public Keys Key
    
        get  return _key; 
    


/// <summary>
/// The enumeration of possible modifiers.
/// </summary>
[Flags]
public enum ModifierKeys : uint

    Alt = 1,
    Control = 2,
    Shift = 4,
    Win = 8

使用（我必须编辑修饰键来投射它们（修饰符）1（修饰符）2等

public partial  class Form1 : Form

    KeyboardHook hook = new KeyboardHook();

    public Form1()
    
        InitializeComponent();

        // register the event that is fired after the key press.
        hook.KeyPressed +=
            new EventHandler<KeyPressedEventArgs>(hook_KeyPressed);
        // register the control + alt + F12 combination as hot key.
        hook.RegisterHotKey(ModifierKeys.Control | ModifierKeys.Alt,
            Keys.F12);
    

    void hook_KeyPressed(object sender, KeyPressedEventArgs e)
    
        // show the keys pressed in a label.
        label1.Text = e.Modifier.ToString() + " + " + e.Key.ToString();
    

【讨论】：

如果我不想要任何修饰键，我应该放什么？ RegisterHotKey() 强制你输入一些东西。

@DanW 我认为枚举有ModifierKeys.None

@DanW 将None = 0 添加到public enum ModifierKeys 声明中，看看是否可行。

公平点，但在极少数情况下，全局使用功能键或键盘可能会很有用。顺便说一句，您的 Add None = 0 建议崩溃了。

在另一个问题上，我似乎无法正确Dispose()。一旦我用RegisterHotKey() 重新创建了热键，热键就无法使用。在处理的时候，我什至还尝试了hook.KeyPressed -= new EventHandler<KeyPressedEventArgs>(myFunc);，但没有成功。我还尝试更改hook.Dispose(); 和hook.KeyPressed -= ...... 的顺序，但没有成功。也许您可以更新您的代码以帮助取消注册。

【参考方案2】：

我从 AaronLS 那里得到了答案，并为简单的单行注册重写了一点。

注册：

GlobalHotKey.RegisterHotKey("Alt + Shift + S", () => DoSomething());

班级：

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Windows.Input;

public class GlobalHotKey : IDisposable

    /// <summary>
    /// Registers a global hotkey
    /// </summary>
    /// <param name="aKeyGesture">e.g. Alt + Shift + Control + Win + S</param>
    /// <param name="aAction">Action to be called when hotkey is pressed</param>
    /// <returns>true, if registration succeeded, otherwise false</returns>
    public static bool RegisterHotKey(string aKeyGestureString, Action aAction)
    
        var c = new KeyGestureConverter();
        KeyGesture aKeyGesture = (KeyGesture)c.ConvertFrom(aKeyGestureString);
        return RegisterHotKey(aKeyGesture.Modifiers, aKeyGesture.Key, aAction);
    

    public static bool RegisterHotKey(ModifierKeys aModifier, Key aKey, Action aAction)
    
        if(aModifier == ModifierKeys.None)
        
            throw new ArgumentException("Modifier must not be ModifierKeys.None");
        
        if (aAction is null)
        
            throw new ArgumentNullException(nameof(aAction));
        

        System.Windows.Forms.Keys aVirtualKeyCode = (System.Windows.Forms.Keys)KeyInterop.VirtualKeyFromKey(aKey);
        currentID = currentID + 1;
        bool aRegistered = RegisterHotKey(window.Handle, currentID,
                                    (uint)aModifier | MOD_NOREPEAT,
                                    (uint)aVirtualKeyCode);

        if(aRegistered)
        
            registeredHotKeys.Add(new HotKeyWithAction(aModifier, aKey, aAction));
        
        return aRegistered;
    

    public void Dispose()
    
        // unregister all the registered hot keys.
        for (int i = currentID; i > 0; i--)
        
            UnregisterHotKey(window.Handle, i);
        

        // dispose the inner native window.
        window.Dispose();
    

    static GlobalHotKey()
    
        window.KeyPressed += (s, e) =>
        
            registeredHotKeys.ForEach(x =>
            
                if (e.Modifier == x.Modifier && e.Key == x.Key)
                
                    x.Action();
                
            );
        ;
    

    private static readonly InvisibleWindowForMessages window = new InvisibleWindowForMessages();
    private static int currentID;
    private static uint MOD_NOREPEAT = 0x4000;
    private static List<HotKeyWithAction> registeredHotKeys = new List<HotKeyWithAction>();

    private class HotKeyWithAction
    

        public HotKeyWithAction(ModifierKeys modifier, Key key, Action action)
        
            Modifier = modifier;
            Key = key;
            Action = action;
        

        public ModifierKeys Modifier  get; 
        public Key Key  get; 
        public Action Action  get; 
    

    // Registers a hot key with Windows.
    [DllImport("user32.dll")]
    private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
    // Unregisters the hot key with Windows.
    [DllImport("user32.dll")]
    private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

    private class InvisibleWindowForMessages : System.Windows.Forms.NativeWindow, IDisposable
    
        public InvisibleWindowForMessages()
        
            CreateHandle(new System.Windows.Forms.CreateParams());
        

        private static int WM_HOTKEY = 0x0312;
        protected override void WndProc(ref System.Windows.Forms.Message m)
        
            base.WndProc(ref m);

            if (m.Msg == WM_HOTKEY)
            
                var aWPFKey = KeyInterop.KeyFromVirtualKey(((int)m.LParam >> 16) & 0xFFFF);
                ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);
                if (KeyPressed != null)
                
                    KeyPressed(this, new HotKeyPressedEventArgs(modifier, aWPFKey));
                
            
        

        public class HotKeyPressedEventArgs : EventArgs
        
            private ModifierKeys _modifier;
            private Key _key;

            internal HotKeyPressedEventArgs(ModifierKeys modifier, Key key)
            
                _modifier = modifier;
                _key = key;
            

            public ModifierKeys Modifier
            
                get  return _modifier; 
            

            public Key Key
            
                get  return _key; 
            
        


        public event EventHandler<HotKeyPressedEventArgs> KeyPressed;

        #region IDisposable Members

        public void Dispose()
        
            this.DestroyHandle();
        

        #endregion
    

【参考方案3】：

这是original answer 的工作vb.net 端口：

KeyboardHook.vb

Imports System.Runtime.InteropServices

Public NotInheritable Class KeyboardHook
    Implements IDisposable

    ' Registers a hot key with Windows.
    <DllImport("user32.dll")> _
    Private Shared Function RegisterHotKey(hWnd As IntPtr, id As Integer, fsModifiers As UInteger, vk As UInteger) As Boolean
    End Function

    ' Unregisters the hot key with Windows.
    <DllImport("user32.dll")> _
    Private Shared Function UnregisterHotKey(hWnd As IntPtr, id As Integer) As Boolean
    End Function

    ''' <summary>
    ''' Represents the window that is used internally to get the messages.
    ''' </summary>
    Private Class Window
        Inherits NativeWindow
        Implements IDisposable
        Private Shared WM_HOTKEY As Integer = &H312

        Public Sub New()
            ' create the handle for the window.
            Me.CreateHandle(New CreateParams())
        End Sub

        Public Event KeyPressed As EventHandler(Of KeyPressedEventArgs)

        ''' <summary>
        ''' Overridden to get the notifications.
        ''' </summary>
        ''' <param name="m"></param>
        Protected Overrides Sub WndProc(ByRef m As Message)
            MyBase.WndProc(m)

            ' check if we got a hot key pressed.
            If m.Msg = WM_HOTKEY Then
                ' get the keys.
                Dim key As Keys = DirectCast((CInt(m.LParam) >> 16) And &HFFFF, Keys)
                Dim modifier As ModifierKeys = DirectCast(CUInt(CInt(m.LParam) And &HFFFF), ModifierKeys)

                ' invoke the event to notify the parent.
                RaiseEvent KeyPressed(Me, New KeyPressedEventArgs(modifier, key))
            End If
        End Sub

#Region " IDisposable Members"

        Public Sub Dispose() Implements IDisposable.Dispose
            Me.DestroyHandle()
        End Sub

#End Region
    End Class

    Private _window As New Window()
    Private _currentId As Integer

    Public Sub New()
        ' register the event of the inner native window.
        AddHandler _window.KeyPressed, Sub(sender As Object, args As KeyPressedEventArgs)
                                           RaiseEvent KeyPressed(Me, args)
                                       End Sub
    End Sub

    ''' <summary>
    ''' Registers a hot key in the system.
    ''' </summary>
    ''' <param name="modifier">The modifiers that are associated with the hot key.</param>
    ''' <param name="key">The key itself that is associated with the hot key.</param>
    Public Sub RegisterHotKey(modifier As ModifierKeys, key As Keys)
        ' increment the counter.
        _currentId = _currentId + 1

        ' register the hot key.
        If Not RegisterHotKey(_window.Handle, _currentId, DirectCast(modifier, UInteger), CUInt(key)) Then
            'Throw New InvalidOperationException("Couldn’t register the hot key.")
            'or use MsgBox("Couldn’t register the hot key.")
        End If
    End Sub

    ''' <summary>
    ''' A hot key has been pressed.
    ''' </summary>
    Public Event KeyPressed As EventHandler(Of KeyPressedEventArgs)

#Region " IDisposable Members"

    Public Sub Dispose() Implements IDisposable.Dispose
        ' unregister all the registered hot keys.
        Dim i As Integer = _currentId
        While i > 0
            UnregisterHotKey(_window.Handle, i)
            System.Math.Max(System.Threading.Interlocked.Decrement(i), i + 1)
        End While

        ' dispose the inner native window.
        _window.Dispose()
    End Sub

#End Region
End Class

''' <summary>
''' Event Args for the event that is fired after the hot key has been pressed.
''' </summary>
Public Class KeyPressedEventArgs
    Inherits EventArgs
    Private _modifier As ModifierKeys
    Private _key As Keys

    Friend Sub New(modifier As ModifierKeys, key As Keys)
        _modifier = modifier
        _key = key
    End Sub

    Public ReadOnly Property Modifier() As ModifierKeys
        Get
            Return _modifier
        End Get
    End Property

    Public ReadOnly Property Key() As Keys
        Get
            Return _key
        End Get
    End Property
End Class

''' <summary>
''' The enumeration of possible modifiers.
''' </summary>
<Flags> _
Public Enum ModifierKeys As UInteger
    Alt = 1
    Control = 2
    Shift = 4
    Win = 8
End Enum

Form1.vb

任务：

将下面的 2 个 Application1 实例替换为您的应用程序名称（在 Visual Studio Solution Explorer 窗口中可以将其视为树的根）。 将对AddGlobalHotkeySupport() 的调用添加到应用程序的初始化阶段。 将对RemoveGlobalHotkeySupport() 的调用添加到您的应用程序的完成阶段。

代码：

Public Sub AddGlobalHotkeySupport()  'TODO: call this at initialization of the application

    ' register the event that is fired after the key press.
    AddHandler hook.KeyPressed, AddressOf hook_KeyPressed

    ' register the control + alt + F12 combination as hot key.
    hook.RegisterHotKey(Application1.ModifierKeys.Control Or Application1.ModifierKeys.Alt, Keys.F12)

End Sub

Public Sub RemoveGlobalHotkeySupport()  'TODO: call this at finalization of the application
    ' unregister all registered hot keys.
    hook.Dispose()
End Sub

Private Sub hook_KeyPressed(sender As Object, e As KeyPressedEventArgs)
    ' show the keys pressed in a label.
    MsgBox(e.Modifier.ToString() + " + " + e.Key.ToString())
End Sub

【讨论】：

类名不应该是键盘钩子，因为这不是键盘钩子。这是一个注册热键并监听 WM_HOTKEY 消息的类。

@MichaelZ。 - 一个很好的收获。 OTOH，这只是来自the other answer 的代码端口，所以也许您最好在此处附上您的评论。