C#键盘钩子 鼠标钩子

最新对C#模拟键盘按键，鼠标操作产生了兴趣。特从网上收集了一些常用的API用来调用键盘，鼠标操作。

class Win32API
{
#region DLL导入

/// <summary>
/// 用于设置窗口
/// </summary>
/// <param name="hWnd"></param>
/// <param name="hWndInsertAfter"></param>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <param name="cx"></param>
/// <param name="cy"></param>
/// <param name="uFlags"></param>
/// <returns></returns>
[DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
public static extern bool SetWindowPos(IntPtr hWnd, int hWndInsertAfter,
int X, int Y, int cx, int cy, int uFlags);

/// <summary>
/// 安装钩子
/// </summary>
/// <param name="idHook"></param>
/// <param name="lpfn"></param>
/// <param name="hInstance"></param>
/// <param name="threadId"></param>
/// <returns></returns>
[DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
public static extern IntPtr SetWindowsHookEx(WH_Codes idHook, HookProc lpfn,
IntPtr pInstance, int threadId);

/// <summary>
/// 卸载钩子
/// </summary>
/// <param name="idHook"></param>
/// <returns></returns>
[DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
public static extern bool UnhookWindowsHookEx(IntPtr pHookHandle);

/// <summary>
/// 传递钩子
/// </summary>
/// <param name="idHook"></param>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
[DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
public static extern int CallNextHookEx(IntPtr pHookHandle, int nCode,
Int32 wParam, IntPtr lParam);

/// <summary>
/// 转换当前按键信息
/// </summary>
/// <param name="uVirtKey"></param>
/// <param name="uScanCode"></param>
/// <param name="lpbKeyState"></param>
/// <param name="lpwTransKey"></param>
/// <param name="fuState"></param>
/// <returns></returns>
[DllImport("user32.dll")]
public static extern int ToAscii(UInt32 uVirtKey, UInt32 uScanCode,
byte[] lpbKeyState, byte[] lpwTransKey, UInt32 fuState);

/// <summary>
/// 获取按键状态
/// </summary>
/// <param name="pbKeyState"></param>
/// <returns>非0表示成功</returns>
[DllImport("user32.dll")]
public static extern int GetKeyboardState(byte[] pbKeyState);

[DllImport("user32.dll")]
public static extern short GetKeyStates(int vKey);

/// <summary>
/// 获取当前鼠标位置
/// </summary>
/// <param name="lpPoint"></param>
/// <returns></returns>
[DllImport("user32.dll")]
public extern static int GetCursorPos(ref POINT lpPoint);

#endregion DLL导入
}

class Hocy_Hook
{
#region 私有常量

/// <summary>
/// 按键状态数组
/// </summary>
private readonly byte[] m_KeyState = new byte[ 256 ];

private string flags;
//flag=0 正常 flag=1 监控状态 flag=2 屏蔽键盘//

#endregion 私有常量

#region 私有变量

/// <summary>
/// 鼠标钩子句柄
/// </summary>
private IntPtr m_pMouseHook = IntPtr.Zero;

/// <summary>
/// 键盘钩子句柄
/// </summary>
private IntPtr m_pKeyboardHook = IntPtr.Zero;

/// <summary>
/// 鼠标钩子委托实例
/// </summary>
/// <remarks>
/// 不要试图省略此变量,否则将会导致
/// 激活 CallbackOnCollectedDelegate 托管调试助手 (MDA)。
/// 详细请参见MSDN中关于 CallbackOnCollectedDelegate 的描述
/// </remarks>
private HookProc m_MouseHookProcedure;

/// <summary>
/// 键盘钩子委托实例
/// </summary>
/// <remarks>
/// 不要试图省略此变量,否则将会导致
/// 激活 CallbackOnCollectedDelegate 托管调试助手 (MDA)。
/// 详细请参见MSDN中关于 CallbackOnCollectedDelegate 的描述
/// </remarks>
private HookProc m_KeyboardHookProcedure;

// 添加
public event MouseEventHandler OnMouseActivity;
private const byte VK_SHIFT = 0x10 ;
private const byte VK_CAPITAL = 0x14;
private const byte VK_NUMLOCK = 0x90;

#endregion 私有变量

#region 事件定义

/// <summary>
/// 鼠标更新事件
/// </summary>
/// <remarks>当鼠标移动或者滚轮滚动时触发</remarks>
public event MouseUpdateEventHandler OnMouseUpdate;

/// <summary>
/// 按键按下事件
/// </summary>
public event KeyEventHandler OnKeyDown;

/// <summary>
/// 按键按下并释放事件
/// </summary>
public event KeyPressEventHandler OnKeyPress;

/// <summary>
/// 按键释放事件
/// </summary>
public event KeyEventHandler OnKeyUp;

#endregion 事件定义

#region 私有方法

/// <summary>
/// 鼠标钩子处理函数
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
private int MouseHookProc( int nCode, Int32 wParam, IntPtr lParam )
{
/*if ( ( nCode >= 0 ) && ( this.OnMouseUpdate != null )
&& ( wParam == ( int )WM_MOUSE.WM_MOUSEMOVE || wParam == ( int )WM_MOUSE.WM_MOUSEWHEEL ) )
{
MouseHookStruct MouseInfo = ( MouseHookStruct )Marshal.PtrToStructure( lParam, typeof( MouseHookStruct ) );
this.OnMouseUpdate( MouseInfo.Point.X, MouseInfo.Point.Y );
}*/
//*
if ((nCode >= 0) && (OnMouseActivity != null))
{
//Marshall the data from callback.
MouseHookStruct mouseHookStruct = (MouseHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));

//detect button clicked
MouseButtons button = MouseButtons.None;
short mouseDelta = 0;
switch (wParam)
{
case (int)WM_MOUSE.WM_LBUTTONDOWN:
//case WM_LBUTTONUP:
//case WM_LBUTTONDBLCLK:
button = MouseButtons.Left;
break;
case (int)WM_MOUSE.WM_RBUTTONDOWN:
//case WM_RBUTTONUP:
//case WM_RBUTTONDBLCLK:
button = MouseButtons.Right;
break;
case (int)WM_MOUSE.WM_MOUSEWHEEL:
//If the message is WM_MOUSEWHEEL, the high-order word of mouseData member is the wheel delta.
//One wheel click is defined as WHEEL_DELTA, which is 120.
//(value >> 16) & 0xffff; retrieves the high-order word from the given 32-bit value
mouseDelta = (short)((mouseHookStruct.MouseData>> 16) & 0xffff);
//TODO: X BUTTONS (I havent them so was unable to test)
//If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP,
//or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released,
//and the low-order word is reserved. This value can be one or more of the following values.
//Otherwise, mouseData is not used.
break;
}

//double clicks
int clickCount = 0;
if (button != MouseButtons.None)
if (wParam == (int)WM_MOUSE.WM_LBUTTONDBLCLK || wParam == (int)WM_MOUSE.WM_RBUTTONDBLCLK) clickCount = 2;
else clickCount = 1;

//generate event
MouseEventArgs e = new MouseEventArgs(
button,
clickCount,
mouseHookStruct.Point.X,
mouseHookStruct.Point.Y,
mouseDelta);
//raise it
OnMouseActivity(this, e);
}

//*

return Win32API.CallNextHookEx( this.m_pMouseHook, nCode, wParam, lParam );
}

/// <summary>
/// 键盘钩子处理函数
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
/// <remarks>此版本的键盘事件处理不是很好,还有待修正.</remarks>
private int KeyboardHookProc( int nCode, Int32 wParam, IntPtr lParam )
{

switch (flags)
{
case "2":
return 1;
break;
case "1":
break;

}
bool handled = false;
//it was ok and someone listens to events
if ((nCode >= 0) && (this.OnKeyDown != null || this.OnKeyUp!= null || this.OnKeyPress!= null))
{
//read structure KeyboardHookStruct at lParam
KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
//raise KeyDown
if (this.OnKeyDown != null && (wParam == (int)WM_KEYBOARD.WM_KEYDOWN || wParam == (int)WM_KEYBOARD.WM_SYSKEYDOWN))
{
Keys keyData = (Keys)MyKeyboardHookStruct.VKCode;
KeyEventArgs e = new KeyEventArgs(keyData);
this.OnKeyDown(this, e);
handled = handled || e.Handled;
}

// raise KeyPress
if (this.OnKeyPress != null && wParam == (int)WM_KEYBOARD.WM_KEYDOWN)
{
bool isDownShift, isDownCapslock;
try
{
isDownShift = ((Win32API.GetKeyStates(VK_SHIFT) & 0x80) == 0x80 ? true : false);
isDownCapslock = (Win32API.GetKeyStates(VK_CAPITAL) != 0 ? true : false);
}
catch
{
isDownCapslock = false;
isDownShift= false;
}

byte[] keyState = new byte[256];
Win32API.GetKeyboardState(keyState);
byte[] inBuffer = new byte[2];
if (Win32API.ToAscii(MyKeyboardHookStruct.VKCode,
MyKeyboardHookStruct.ScanCode,
keyState,
inBuffer,
MyKeyboardHookStruct.Flags) == 1)
{
char key = (char)inBuffer[0];
if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) key = Char.ToUpper(key);
KeyPressEventArgs e = new KeyPressEventArgs(key);
this.OnKeyPress(this, e);
handled = handled || e.Handled;
}
}
// raise KeyUp
if (this.OnKeyUp != null && (wParam == (int)WM_KEYBOARD.WM_KEYUP || wParam == (int)WM_KEYBOARD.WM_SYSKEYUP))
{
Keys keyData = (Keys)MyKeyboardHookStruct.VKCode;
KeyEventArgs e = new KeyEventArgs(keyData);
this.OnKeyUp(this, e);
handled = handled || e.Handled;
}

}

//if event handled in application do not handoff to other listeners
if (handled)
return 1;
else
return Win32API.CallNextHookEx(this.m_pKeyboardHook, nCode, wParam, lParam);
}

#endregion 私有方法

#region 公共方法

/// <summary>
/// 安装钩子
/// </summary>
/// <returns></returns>
public bool InstallHook(string flagsinfo)
{
this.flags = flagsinfo;
IntPtr pInstance = Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().ManifestModule);
//pInstance = (IntPtr)4194304;
// IntPtr pInstanc2 = Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly());
// Assembly.GetExecutingAssembly().GetModules()[0]
// 假如没有安装鼠标钩子
if ( this.m_pMouseHook == IntPtr.Zero )
{
this.m_MouseHookProcedure = new HookProc( this.MouseHookProc );
this.m_pMouseHook = Win32API.SetWindowsHookEx( WH_Codes.WH_MOUSE_LL,this.m_MouseHookProcedure, pInstance, 0 );
if ( this.m_pMouseHook == IntPtr.Zero )
{
this.UnInstallHook();
return false;
}
}
if ( this.m_pKeyboardHook == IntPtr.Zero )
{
this.m_KeyboardHookProcedure = new HookProc( this.KeyboardHookProc );
this.m_pKeyboardHook = Win32API.SetWindowsHookEx( WH_Codes.WH_KEYBOARD_LL, this.m_KeyboardHookProcedure, pInstance, 0 );
if ( this.m_pKeyboardHook == IntPtr.Zero )
{
this.UnInstallHook();
return false;
}
}

return true;
}

/// <summary>
/// 卸载钩子
/// </summary>
/// <returns></returns>
public bool UnInstallHook()
{
bool result = true;
if ( this.m_pMouseHook != IntPtr.Zero )
{
result = ( Win32API.UnhookWindowsHookEx( this.m_pMouseHook ) && result );
this.m_pMouseHook = IntPtr.Zero;
}
if ( this.m_pKeyboardHook != IntPtr.Zero )
{
result = ( Win32API.UnhookWindowsHookEx( this.m_pKeyboardHook ) && result );
this.m_pKeyboardHook = IntPtr.Zero;
}

return result;
}

#endregion 公共方法

#region 构造函数

/// <summary>
/// 钩子类
/// </summary>
/// <remarks>本类仅仅简单实现了 WH_KEYBOARD_LL 以及 WH_MOUSE_LL </remarks>
public Hocy_Hook()
{

Win32API.GetKeyboardState( this.m_KeyState );
}

#endregion 构造函数
}

时间： 2024-10-31 07:54:46

C#键盘钩子 鼠标钩子的相关文章

c#键盘鼠标钩子

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Windows.Forms; 6 using System.Runtime.InteropServices; 7 using System.ComponentModel; 8 using System.Reflection; 9 10 namespace Alif.CommonAP

HOOK API （一）——HOOK基础+一个鼠标钩子实例

HOOK API (一)——HOOK基础+一个鼠标钩子实例 0x00 起因 最近在做毕业设计,有一个功能是需要实现对剪切板的监控和进程的防终止保护.原本想从内核层实现,但没有头绪.最后决定从调用层入手,即采用HOOK API的技术来挂钩相应的API,从而实现预期的功能.在这样的需求下,就开始学习了HOOK API. 0x01什么是HOOK API HOOK(钩子,挂钩)是一种实现Windows平台下类似于中断的机制[24].HOOK机制允许应用程序拦截并处理Windows消息或指定事件,当指定的

用Delphi实现Windows的鼠标钩子函数

Delphi是基于PASCAL语言的Windows编程工具,功能十分强大.然而在Delphi的帮助文件中,对Windows API函数的说明沿袭了 VC 的格式,和VC一样,对很多API函数的用法没有举例子详细说明,对一些深入系统内部的API函数更是语焉不详,给编程者带来不便.笔者仅就在Windows编程中鼠标钩子函数(HOOK)的实现,举例作一说明.   鼠标钩子函数也可叫做鼠标消息过滤器,是一种回调(CALLBACK)函数,归系统调用.如果用SetWindowsHook或SetWindows

VC6 鼠标钩子 最简单样例

Windows系统是建立在事件驱动的机制上的,说穿了就是整个系统都是通过消息的传递来实现的.而钩子是Windows系统中非常重要的系统接口,用它能够截获并处理送给其它应用程序的消息,来完毕普通应用程序难以实现的功能.钩子能够监视系统或进程中的各种事件消息,截获发往目标窗体的消息并进行处理.这样,我们就能够在系统中安装自己定义的钩子,监视系统中特定事件的发生,完毕特定的功能,比方截获键盘.鼠标的输入,屏幕取词,日志监视等等.可见,利用钩子能够实现很多特殊而实用的功能.因此,对于高级编程人员来说,掌

钩子编程（HOOK） 安装进程内鼠标钩子

作者 : 卿笃军 钩子函数: WINDOWS的钩子函数可以认为是WINDOWS的主要特性之一.利用它们,您可以捕捉您自己进程或其它进程发生的事件.通过"钩挂",您可以给WINDOWS一个处理或过滤事件的回调函数,该函数也叫做"钩子函数",当每次发生您感兴趣的事件时,WINDOWS都将调用该函数. 下面介绍如何安装一个进程内的鼠标钩子. 第一步:打开VC6.0,新建一个基于对话框的MFC应用程序. 第二步:将如下代码拷贝到BOOL CInnerHookDlg::OnI

获取键盘或鼠标多久没有对屏幕进行操作了

屏幕保护相关代码: 1 using System; 2 using System.Collections.Generic; 3 using System.ComponentModel; 4 using System.Data; 5 using System.Drawing; 6 using System.Linq; 7 using System.Text; 8 using System.Windows.Forms; 9 using System.Threading; 10 using Syste

winform中键盘和鼠标事件的捕捉和重写（转）

在 编写winform应用程序时,有时需要无论在哪个控件获取焦点时,对某一个键盘输入或者鼠标事件都进行同样的操作.比如编写一个处理图片的应用程序时, 希望无论当前哪个控件获得焦点,当用户按上.下.左.右键时,图片控件的滚动条都会上下左右移动,当用户拨动鼠标滚轮时图片总能发大或缩小.如果对每个控 件的键盘或鼠标事件都进行设置,必然会造成很多的重复工作.本文我将介绍如何在winform下对某一个键盘输入或者鼠标事件进行相同的操作. 1.键盘事件的捕捉和重写 首先是键盘操作,为了实现上述功能,现在介绍

DeskMini无传统机械键盘与鼠标接口的情况下使用U盘安装系统经验总结

总结安装纯净版Win7旗舰版系统安装过程所解决的问题要点: 1:UEFI引导启动的实现. 2:使用Dism++实现系统的安装. 3:使用Dism++解决新主板在安装系统过程中不能使用USB键盘和鼠标的问题. 解决过程: 准备工作: 去MSDN网站下载Win7SP1纯净版的ISO文件.(Windows 7 Ultimate with Service Pack 1 (x64) - DVD (Chinese-Simplified) : ed2k://|file|cn_windows_7_ultimat

MFC中热键&模拟键盘&模拟鼠标的使用

1. 热键的使用 热键不用了的话一定要卸载,否则下次启动时会被占用. 函数原型 注册函数 BOOL RegisterHotKey( HWND hWnd, // handle to window int id, // hot key identifier UINT fsModifiers, // key-modifier options UINT vk // virtual-key code ); hWnd------窗口句柄: id------热键的标识:(如果是exe 这个标识的范围就在0-4