• C# HotKey 的另一种方法


    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Runtime.InteropServices;
    
    namespace ConsoleApplication1
    {
        /// <summary>
        /// A class that manages a global low level keyboard hook
        /// </summary>
        class globalKeyboardHook
        {
            #region Constant, Structure and Delegate Definitions
            /// <summary>
            /// defines the callback type for the hook
            /// </summary>
            public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
    
            public struct keyboardHookStruct
            {
                public int vkCode;
                public int scanCode;
                public int flags;
                public int time;
                public int dwExtraInfo;
            }
    
            const int WH_KEYBOARD_LL = 13;
            const int WM_KEYDOWN = 0x100;
            const int WM_KEYUP = 0x101;
            const int WM_SYSKEYDOWN = 0x104;
            const int WM_SYSKEYUP = 0x105;
            #endregion
    
            keyboardHookProc khp;
    
            #region Instance Variables
            /// <summary>
            /// The collections of keys to watch for
            /// </summary>
            public List<int> HookedKeys = new List<int>();
            /// <summary>
            /// Handle to the hook, need this to unhook and call the next hook
            /// </summary>
            IntPtr hhook = IntPtr.Zero;
            #endregion
    
            #region Events
            /// <summary>
            /// Occurs when one of the hooked keys is pressed
            /// </summary>
            public event EventHandler<KeyDownUpEventArgs> KeyDown;
            /// <summary>
            /// Occurs when one of the hooked keys is released
            /// </summary>
            public event EventHandler<KeyDownUpEventArgs> KeyUp;
            #endregion
    
            #region Constructors and Destructors
            /// <summary>
            /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
            /// </summary>
            public globalKeyboardHook()
            {
                khp = new keyboardHookProc(hookProc);
                hook();
            }
    
            /// <summary>
            /// Releases unmanaged resources and performs other cleanup operations before the
            /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
            /// </summary>
            ~globalKeyboardHook()
            {
                unhook();
            }
            #endregion
    
            #region Public Methods
            /// <summary>
            /// Installs the global hook
            /// </summary>
            public void hook()
            {
                IntPtr hInstance = LoadLibrary("User32");
                hhook = SetWindowsHookEx(WH_KEYBOARD_LL, khp, hInstance, 0);
            }
    
            /// <summary>
            /// Uninstalls the global hook
            /// </summary>
            public void unhook()
            {
                UnhookWindowsHookEx(hhook);
            }
    
            /// <summary>
            /// The callback for the keyboard hook
            /// </summary>
            /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
            /// <param name="wParam">The event type</param>
            /// <param name="lParam">The keyhook event information</param>
            /// <returns></returns>
            public int hookProc(int code, int wParam, ref keyboardHookStruct lParam)
            {
                if (code >= 0)
                {
                    var key = new KeyDownUpEventArgs(lParam.vkCode);
                    if (HookedKeys.Contains(key.KeyCode))
                    {
                        if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null))
                        {
                            KeyDown(this, key);
                        }
                        else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null))
                        {
                            KeyUp(this, key);
                        }
                        if (key.Handled)
                            return 1;
                    }
                }
                return CallNextHookEx(hhook, code, wParam, ref lParam);
            }
            #endregion
    
            #region DLL imports
            /// <summary>
            /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
            /// </summary>
            /// <param name="idHook">The id of the event you want to hook</param>
            /// <param name="callback">The callback.</param>
            /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
            /// <param name="threadId">The thread you want to attach the event to, can be null</param>
            /// <returns>a handle to the desired hook</returns>
            [DllImport("user32.dll")]
            static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
    
            /// <summary>
            /// Unhooks the windows hook.
            /// </summary>
            /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
            /// <returns>True if successful, false otherwise</returns>
            [DllImport("user32.dll")]
            static extern bool UnhookWindowsHookEx(IntPtr hInstance);
    
            /// <summary>
            /// Calls the next hook.
            /// </summary>
            /// <param name="idHook">The hook id</param>
            /// <param name="nCode">The hook code</param>
            /// <param name="wParam">The wparam.</param>
            /// <param name="lParam">The lparam.</param>
            /// <returns></returns>
            [DllImport("user32.dll")]
            static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
    
            /// <summary>
            /// Loads the library.
            /// </summary>
            /// <param name="lpFileName">Name of the library</param>
            /// <returns>A handle to the library</returns>
            [DllImport("kernel32.dll")]
            static extern IntPtr LoadLibrary(string lpFileName);
            #endregion
        }
    
        public class KeyDownUpEventArgs : EventArgs
        {
            public KeyDownUpEventArgs(int keyCode)
            {
                this.KeyCode = keyCode;
            }
    
            public int KeyCode { get; private set; }
            public bool Handled { get; set; }
        }
    }
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Diagnostics;
    
    namespace ConsoleApplication1
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
    
            private void Form1_Load(object sender, EventArgs e)
            {
                globalKeyboardHook gkh = new globalKeyboardHook();
                gkh.HookedKeys.Add(66);
                gkh.KeyDown += new EventHandler<KeyDownUpEventArgs>(gkh_KeyDown);
                
            }
    
            void gkh_KeyDown(object sender, KeyDownUpEventArgs e)
            {
                Process.Start(@"c:\windows\system32\cmd.exe"); 
            }
        }
    }
  • 相关阅读:
    为什么 TCP 建立连接是三次握手,关闭连接确是四次挥手呢?
    一文搞懂 Java 中的枚举,写得非常好!
    IntelliJ IDEA For Mac 快捷键,够骚,速度收藏!
    Java Bean 为什么必须要有一个无参构造函数?
    18 个示例带你掌握 Java 8 日期时间处理!
    从入门到熟悉 HTTPS 的 9 个问题
    MyBatis的动态SQL详解
    MyBatis总结-实现关联表查询
    AngularJS
    Spring MVC url提交参数和获取参数
  • 原文地址:https://www.cnblogs.com/nanfei/p/2973900.html
Copyright © 2020-2023  润新知