C#全局鼠标键盘Hook (备查)

最新推荐文章于 2024-08-20 16:43:18 发布
最新推荐文章于 2024-08-20 16:43:18 发布
阅读量1.2k 收藏 5
点赞数
分类专栏： asp.net 文章标签： hook c# exception object keyboard button
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;

namespace Study
{
    //   <summary> 
    ///   这个类可以让你得到一个在运行中程序的所有键盘或鼠标事件 
    ///   并且引发一个带KeyEventArgs参数的.NET事件以便你很容易使用这些信息 
    ///   </summary>

    public class KeyBordHook
    {
        private const int WM_KEYDOWN = 0x100;
        private const int WM_KEYUP = 0x101;
        private const int WM_SYSKEYDOWN = 0x104;
        private const int WM_SYSKEYUP = 0x105;

        //全局的事件 
        public event KeyEventHandler OnKeyDownEvent;
        public event KeyEventHandler OnKeyUpEvent;
        public event KeyPressEventHandler OnKeyPressEvent;
        static int hKeyboardHook = 0;   //键盘钩子句柄 
        //鼠标常量 
        public const int WH_KEYBOARD_LL = 13;   //keyboard   hook   constant   
        HookProc KeyboardHookProcedure;   //声明键盘钩子事件类型. 
        //声明键盘钩子的封送结构类型 
        [StructLayout(LayoutKind.Sequential)]
        public class KeyboardHookStruct
        {
            public int vkCode;   //表示一个在1到254间的虚似键盘码 
            public int scanCode;   //表示硬件扫描码 
            public int flags;
            public int time;
            public int dwExtraInfo;
        }
        //装置钩子的函数 
        [DllImport("user32.dll ", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
        //卸下钩子的函数 
        [DllImport("user32.dll ", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);

        //下一个钩挂的函数 
        [DllImport("user32.dll ", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);
        [DllImport("user32 ")]
        public static extern int ToAscii(int uVirtKey, int uScanCode, byte[] lpbKeyState, byte[] lpwTransKey, int fuState);
        [DllImport("user32 ")]
        public static extern int GetKeyboardState(byte[] pbKeyState);
        public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);
        ///   <summary> 
        ///   墨认的构造函数构造当前类的实例并自动的运行起来. 
        ///   </summary> 
        public KeyBordHook()
        {
            Start();
        }
        //析构函数. 
        ~KeyBordHook()
        {
            Stop();
        }
        public void Start()
        {
            //安装键盘钩子   
            if (hKeyboardHook == 0)
            {
                KeyboardHookProcedure = new HookProc(KeyboardHookProc);
                hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().ManifestModule), 0);
                if (hKeyboardHook == 0)
                {
                    Stop();
                    throw new Exception("SetWindowsHookEx   ist   failed. ");
                }
                
            }
        }
        public void Stop()
        {
            bool retKeyboard = true;

            if (hKeyboardHook != 0)
            {
                retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
                hKeyboardHook = 0;
            }
            //如果卸下钩子失败 
            if (!(retKeyboard)) throw new Exception("UnhookWindowsHookEx   failed. ");
        }
        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            if ((nCode >= 0) && (OnKeyDownEvent != null || OnKeyUpEvent != null || OnKeyPressEvent != null))
            {
                KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
                //引发OnKeyDownEvent 
                if (OnKeyDownEvent != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
                {
                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
                    KeyEventArgs e = new KeyEventArgs(keyData);
                    OnKeyDownEvent(this, e);
                }

                //引发OnKeyPressEvent 
                if (OnKeyPressEvent != null && wParam == WM_KEYDOWN)
                {
                    byte[] keyState = new byte[256];
                    GetKeyboardState(keyState);
                    byte[] inBuffer = new byte[2];
                    if (ToAscii(MyKeyboardHookStruct.vkCode,
                      MyKeyboardHookStruct.scanCode,
                      keyState,
                      inBuffer,
                      MyKeyboardHookStruct.flags) == 1)
                    {
                        KeyPressEventArgs e = new KeyPressEventArgs((char)inBuffer[0]);
                        OnKeyPressEvent(this, e);
                    }
                }

                //引发OnKeyUpEvent 
                if (OnKeyUpEvent != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
                {
                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
                    KeyEventArgs e = new KeyEventArgs(keyData);
                    OnKeyUpEvent(this, e);
                }

            }
            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
        }
    }


    ///   <summary> 
    ///   这个类可以让你得到一个在运行中程序的所有鼠标事件 
    ///   并且引发一个带MouseEventArgs参数的.NET鼠标事件以便你很容易使用这些信息 
    ///   </summary> 
    public class MouseHook
    {
        private const int WM_MOUSEMOVE = 0x200;
        private const int WM_LBUTTONDOWN = 0x201;
        private const int WM_RBUTTONDOWN = 0x204;
        private const int WM_MBUTTONDOWN = 0x207;
        private const int WM_LBUTTONUP = 0x202;
        private const int WM_RBUTTONUP = 0x205;
        private const int WM_MBUTTONUP = 0x208;
        private const int WM_LBUTTONDBLCLK = 0x203;
        private const int WM_RBUTTONDBLCLK = 0x206;
        private const int WM_MBUTTONDBLCLK = 0x209;
        //全局的事件 
        public event MouseEventHandler OnMouseActivity;
        static int hMouseHook = 0;   //鼠标钩子句柄 
        //鼠标常量 
        public const int WH_MOUSE_LL = 14;   //mouse   hook   constant 
        HookProc MouseHookProcedure;   //声明鼠标钩子事件类型. 
        //声明一个Point的封送类型 
        [StructLayout(LayoutKind.Sequential)]
        public class POINT
        {
            public int x;
            public int y;
        }
        //声明鼠标钩子的封送结构类型 
        [StructLayout(LayoutKind.Sequential)]
        public class MouseHookStruct
        {
            public POINT pt;
            public int hWnd;
            public int wHitTestCode;
            public int dwExtraInfo;
        }
        //装置钩子的函数 
        [DllImport("user32.dll ", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
        //卸下钩子的函数 
        [DllImport("user32.dll ", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);

        //下一个钩挂的函数 
        [DllImport("user32.dll ", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);
        public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);
        ///   <summary> 
        ///   墨认的构造函数构造当前类的实例. 
        ///   </summary> 
        public MouseHook()
        {
            //Start(); 
        }
        //析构函数. 
        ~MouseHook()
        {
            Stop();
        }
        public void Start()
        {
            //安装鼠标钩子 
            if (hMouseHook == 0)
            {
                //生成一个HookProc的实例. 
                MouseHookProcedure = new HookProc(MouseHookProc);
                hMouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
                //如果装置失败停止钩子 
                if (hMouseHook == 0)
                {
                    Stop();
                    throw new Exception("SetWindowsHookEx failed. ");
                }
            }
        }
        public void Stop()
        {
            bool retMouse = true;
            if (hMouseHook != 0)
            {
                retMouse = UnhookWindowsHookEx(hMouseHook);
                hMouseHook = 0;
            }

            //如果卸下钩子失败 
            if (!(retMouse)) throw new Exception("UnhookWindowsHookEx   failed. ");
        }
        private int MouseHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            //如果正常运行并且用户要监听鼠标的消息 
            if ((nCode >= 0) && (OnMouseActivity != null))
            {
                MouseButtons button = MouseButtons.None;
                int clickCount = 0;
                switch (wParam)
                {
                    case WM_LBUTTONDOWN:
                        button = MouseButtons.Left;
                        clickCount = 1;
                        break;
                    case WM_LBUTTONUP:
                        button = MouseButtons.Left;
                        clickCount = 1;
                        break;
                    case WM_LBUTTONDBLCLK:
                        button = MouseButtons.Left;
                        clickCount = 2;
                        break;
                    case WM_RBUTTONDOWN:
                        button = MouseButtons.Right;
                        clickCount = 1;
                        break;
                    case WM_RBUTTONUP:
                        button = MouseButtons.Right;
                        clickCount = 1;
                        break;
                    case WM_RBUTTONDBLCLK:
                        button = MouseButtons.Right;
                        clickCount = 2;
                        break;
                }
                //从回调函数中得到鼠标的信息 
                MouseHookStruct MyMouseHookStruct = (MouseHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));
                MouseEventArgs e = new MouseEventArgs(button, clickCount, MyMouseHookStruct.pt.x, MyMouseHookStruct.pt.y, 0);
                OnMouseActivity(this, e);
            }
            return CallNextHookEx(hMouseHook, nCode, wParam, lParam);
        }
    }
}


Example:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Study
{
    public partial class WinProcTest : Form
    {
        public WinProcTest()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            KeyBordHook kbh = new KeyBordHook();
            kbh.OnKeyDownEvent += new KeyEventHandler(WinProcTest_KeyDown);
            kbh.OnKeyPressEvent += new KeyPressEventHandler(WinProcTest_KeyPress);
            kbh.OnKeyUpEvent += new KeyEventHandler(WinProcTest_KeyUp);
            kbh.Start();
        }
        private void WinProcTest_KeyDown(object sender, KeyEventArgs e)
        {
            this.Text = e.KeyData.ToString();
        }
        private void WinProcTest_KeyPress(object sender, KeyPressEventArgs e)
        {
           // this.Text = "press";
        }
        private void WinProcTest_KeyUp(object sender, KeyEventArgs e)
        {
           // this.Text = "up";
        }
        private void WinProcTest_Mouse(object sender, MouseEventArgs e)
        {
            this.Text = "mouse";
        }
        private void button2_Click(object sender, EventArgs e)
        {
            MouseHook mh = new MouseHook();
            mh.OnMouseActivity += new MouseEventHandler(WinProcTest_Mouse);
            mh.Start();
        }

        private void button3_KeyDown(object sender, KeyEventArgs e)
        {
            this.Text = e.KeyData.ToString();
        }
    }
}


In this way,  we can get the keyboard or mouse event from the full screen, not just the application focused.
注意,全局钩子,在vs05中debug会总是说钩子失败,但直接运行是可以挂上钩子的



sfz_roger
关注
专栏目录
C# 键盘鼠标全局钩子（拦截键盘鼠标所有操作）全局HOOK
01-05
C#实现键盘鼠标全局钩子 VS2013，可编译运行，带DEMO 可全局拦截鼠标单击/双击/滚动事件 可全局拦截键盘按键事件 可锁定键盘鼠标输入，比如锁屏！ 该代码无法屏蔽Ctrl +alt +delete 需要实现所有拦截，请参考相关C++实现
C# 全局勾子(Hook 含鼠标键盘窗口内核等）
01-19
含鼠标键盘窗口内核等,利用C++制作的DLL，用C#写的全局勾子程序，并配有测试代码。
c# 使用hook来监控鼠标键盘事件的示例代码
weixin_30399797的博客
01-30 571
如果这个程序在10几年前,QQ刚刚兴起的时候,有了这个代码,就可实现盗号了. 当然使用钩子我们更多的是实现"全局快捷键"的需求. 比如 程序最小化隐藏后要"某快捷键"来启动它. 钩子(hook),通俗的讲,她可以捕获到你的键盘和鼠标的相关操作消息. 关于hook的相关代码网上一搜一箩筐,这是整理起来比较完善和使用最方便的. //Declare wrapper manag...
c#检测并显示组合按键（ctrl+alt+shift）快捷热键，在窗体隐藏或失去焦点时检测（全局）组合热键（非钩子（Hook）机制）
最新发布
mybluedesky的博客
08-20 504
c#检测并显示组合按键（ctrl+alt+shift）快捷热键，在窗体隐藏或失去焦点时检测（全局）组合热键（非钩子（Hook）机制）
如何在C#中使用全局鼠标、键盘Hook
weixin_33853794的博客
09-22 329
　　今天，有个同事问我，怎样在C#中使用全局钩子？以前写的全局钩子都是用unmanaged C或C++写个DLL来实现，可大家都知道，C#是基于.Net Framework的，是managed，怎么实现全局钩子呢？于是开始到网上搜索，好不容易找到一篇，318804 - HOW TO: Set a Windows Hook in Visual C# .NET，里面详细的说明了如何使用鼠标钩子捕获鼠标...
C#全局鼠标键盘Hook
09-10 2770
<br />using System;<br />using System.Collections.Generic;<br />using System.Reflection;<br />using System.Runtime.InteropServices;<br />using System.Text;<br />using System.Windows.Forms;<br /><br />namespace Study<br />{<br />    //   <summary> <br />   
C# Hock 全局监听程序外的键盘和鼠标的事件
05-29
"C# Hook 钩子"就是这样一个专题，它允许开发者创建一个全局监听程序，来捕获并处理系统的键盘和鼠标事件。 钩子是一种机制，由Windows操作系统提供，它允许应用程序设置一个或多个“钩子”，以便拦截特定类型的...
C++全局键盘鼠标Hook
04-27
本主题聚焦于"C++全局键盘鼠标Hook"，它允许开发者监控和控制用户的键盘和鼠标活动，甚至可以在目标进程中注入代码以实现更高级的功能。 全局键盘鼠标Hook主要涉及到Windows API中的`SetWindowsHookEx`函数，它是...
在C#中使用全局鼠标、键盘Hook
11-14
在C#编程中，有时我们需要捕获系统的全局鼠标和键盘事件，这通常涉及到Windows API的使用，特别是通过创建钩子（Hook）来实现。全局钩子允许我们的应用程序监听系统范围内的输入事件，无论焦点在哪个窗口。下面我们...
C# Hook 屏蔽键盘按键
07-20
C#屏蔽键盘按键
C#使用全局钩子(hook)
11-22
介绍C#开发中在使用钩子对键盘鼠标等事件进行监听时出现错误的解决方法
c#源码 全局的hook 全局钩子
06-10
c# 源码 全局 hook 钩子 能够在后台全局监控鼠标和键盘的一举一动
C#全局键盘Hook Demo
09-08
一个 简单的 全局键盘钩子的一个 很简单实例
深入分析C#键盘勾子(Hook)拦截器,屏蔽键盘活动的详解
12-31
钩子(Hook)，是Windows消息处理机制的一个平台,应用程序可以在上面设置子程以监视指定窗口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，在目标窗口处理函数之前处理它。钩子机制允许应用程序截获处理window消息或特定事件。 钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出，在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传递。运行机制1、钩子链表和钩子子程：每一个Hook都有一个与之相关联的指针列表，称之为钩子链表，由
c# 钩子(hook)键盘
Violinlins
12-22 770
#region progressBar实时显示进度  private void button1_Click(object sender, EventArgs e)  {      int i = 10000;      progressBar1.Minimum = 0;      progressBar1.Maximum = i;      for (int k = 0; k     {     
C#.Net的全局键盘钩子(Hook)技术
weixin_30488313的博客
07-22 388
usingSystem; usingSystem.Windows.Forms; usingSystem.Runtime.InteropServices; usingSystem.Reflection; namespaceHookDll { publicclassHookDll { privateKBDLLHOOKSTRUCTkbdllhs; ...
C#实现全局鼠标键盘监听Hook技术
"C#全局鼠标键盘Hook" 在C#编程中，全局鼠标键盘Hook是一种技术，允许开发者捕获和处理系统级别的键盘和鼠标事件，即使这些事件发生在应用程序之外。这通常通过使用Windows API（应用程序接口）来实现。给定的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值