WinForm中实现HotKey

最近在写一个游戏辅助工具，来点Win变成的总结

主要用了RegisterHotKey；UnregisterHotKey；两个winAPI

以下代码来自stackoverflow新增了一个HotKeyManager类

  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 >> ) & 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 + ;

            // 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 > ; i--)
            {
                UnregisterHotKey(_window.Handle, i);
            }

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

        #endregion
    }

    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; }
        }
    }

    [Flags]
    public enum ModifierKeys : uint
    {
        None=,
        Alt = ,
        Control = ,
        Shift = ,
        Win =
    }

下面是自己封装的一个类

    public class KeysInfo {
        public Keys Key { get; set; }
        public Action<object, KeyPressedEventArgs> Action { get; set; }
    }

    public class HotKeyManager
    {
        private KeyboardHook keyhook = new KeyboardHook();
        public List<KeysInfo> KeysInfos { get; set; }

        public HotKeyManager(List<KeysInfo> List)
        {
            this.KeysInfos = List;
        }
        public void RegisterKey()
        {
            keyhook.KeyPressed +=new EventHandler<KeyPressedEventArgs>(hook_KeyPressed);
            foreach (var item in KeysInfos)
            {
                keyhook.RegisterHotKey(0, item.Key);
            }
        }

        private void hook_KeyPressed(object sender, KeyPressedEventArgs e)
        {
            foreach (var item in KeysInfos)
            {
                if (e.Key == item.Key)
                {
                    item.Action(sender,e);
                }
            }
        }
    }

　　使用

private void MainForm_Load(object sender, EventArgs e)
        {
            LoadGridView();
            HotKeyManager hotkey = new HotKeyManager(
                new List<KeysInfo>()
                {
                    new KeysInfo {
                        Key =Keys.Home,
                        Action =new Action<object, KeyPressedEventArgs>(
                            (object keySender, KeyPressedEventArgs eventArg)=>
                            {
                                if (eventArg.Key==Keys.Home)
                                {
                                    this.Show();
                                }
                             })
                    },
                     new KeysInfo {
                        Key =Keys.End,
                        Action =new Action<object, KeyPressedEventArgs>(
                            (object keySender, KeyPressedEventArgs eventArg)=>
                            {
                                if (eventArg.Key==Keys.End)
                                {
                                    this.Hide();
                                }
                             })
                    }
                });
            hotkey.RegisterKey();
        }