消息钩子(消息钩子是什么有什么用)

一、系统钩子的什么是钩子

其实Windows系统是建立在事件驱动的机制上的，说穿了就是整个系统都是通过消息的传递来实现的。而钩子是Windows系统中非常重要的系统接口，用它可以截获并处理送给其他应用程序的消息，来完成普通应用程序难以实现的功能。

可见，利用钩子可以实现许多特殊而有用的功能。因此，对于高级编程人员来说，掌握钩子的编程方法是很有必要的。

钩子的种类很多，每种钩子可以截获并处理相应的消息，如键盘钩子可以截获键盘消息，外壳钩子可以截取、启动和关闭应用程序的消息等。

如图所示是一全局钩子示意图

在实例程序中运用WH_GETMESSAGE钩子，这个钩子监视投递到消息队列中的Windows消息。

钩子可以分为线程钩子和系统钩子,线程钩子监视指定线程的事件消息,系统钩子监视系统中的所有线程的事件消息。因为系统钩子会影响系统中所有的应用程序，所以钩子函数必须放在独立的动态链接库(DLL)中。 1． windows的钩子程序，需要用到几个sdk中的api函数。下面列出这几个函数的原型及说明：

hhook setwindowshookex(int idhook,hook_proc lpfn,hinstance hmod,dword dwthreadid);

参数说明如下：

idhook：钩子的类型

lpfn：钩子处理函数地址

hmod：包含钩子函数的模块句柄

dwthreadid：钩子的监控线程

函数说明：函数将在系统中挂上一个由idhook指定类型的钩子，监控并处理相应的特定消息。

bool unhookwindowshookex(hhook hhk);

函数说明：函数将撤销由hhk指定的钩子。

lresult callnexthookex( hhook hhk, int ncode,wparam wparam,lparam lparam);

函数说明：函数将消息向下传递，下一个钩子处理将截获这一消息。

2．由于钩子的处理涉及到模块及进程间的数据地址问题，一般情况是把钩子整合到一个动态链接库（dll）中，VC中有三种形式的MFC DLL可供选择，即Regular statically linked to MFC DLL（标准静态链接MFC DLL）、Regular using the shared MFC DLL（标准动态链接MFC DLL）以及Extension MFC DLL（扩展MFC DLL）。第一种DLL在编译时把使用的MFC代码链接到DLL中，执行程序时不需要其他MFC动态链接类库的支持，但体积较大；第二种DLL在运行时动态链接到MFC类库，因而体积较小，但却依赖于MFC动态链接类库的支持；这两种DLL均可被MFC程序和Win32程序使用。第三种DLL的也是动态连接，但做为MFC类库的扩展，只能被MFC程序使用。

另外,要设立一个全局数据共享数据段，以存贮一些全局变量，保留上次钩子消息事件发生时的状态。

3． Win32 DLL的入口和出口函数都是DLLMain。只要有进程或线程载入和卸载DLL时，都会调用该函数，其原型是：

BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason, LPVOID lpvReserved);其中，第一个参数表示DLL的实例句柄；第三个参数系统保留；第二个参数指明了当前调用该动态连接库的状态，它有四个可能的值：DLL_PROCESS_ATTACH（进程载入）、DLL_THREAD_ATTACH（线程载入）、DLL_THREAD_DETACH（线程卸载）、DLL_PROCESS_DETACH（进程卸载）。在DLLMain函数中可以通过对传递进来的这个参数的值进行判别，根据不同的参数值对DLL进行必要的初始化或清理工作。由于在Win32环境下，所有进程的空间都是相互独立的，这减少了应用程序间的相互影响，但大大增加了编程的难度。当进程在动态加载DLL时，系统自动把DLL地址映射到该进程的私有空间，而且也复制该DLL的全局数据的一份拷贝到该进程空间，每个进程所拥有的相同的DLL的全局数据其值却并不一定是相同的。当DLL内存被映射到进程空间中，每个进程都有自己的全局内存拷贝，加载DLL的每一个新的进程都重新初始化这一内存区域，也就是说进程不能再共享DLL。因此，在Win32环境下要想在多个进程中共享数据，就必须进行必要的设置。一种方法便是把这些需要共享的数据单独分离出来，放置在一个独立的数据段里，并把该段的属性设置为共享，建立一个内存共享的DLL。建立钩子程序时需要把钩子处理整合到动态链接库中，所以例程中需要建立两个project。

1．钩子处理动态链接库

（1）选择mfc appwizard(dll)创建一个新project，命名为“spy”。

（2）选择mfc extension dll类型。

（3）创建一个新的头文件，命名为“hook.h”，修改它的代码如下：

extern C LRESULT CALLBACK mouseproc(int code,WPARAM wparam,LPARAM lparam);//钩子处理函数

extern C bool WINAPI starthook();//启动钩子函数

extern C bool WINAPI stophook();//撤销钩子函数

extern C int WINAPI getresultl();//取得鼠标左键单击次数的函数

extern C int WINAPI getresultr();//取得鼠标右键单击次数的函数

（4）修改spy.cpp程序代码如下:

#include hook.h//包含头文件hook

#pragma data_seg(publicdata)//定义全局数据段

HHOOK hhook=NULL;//钩子句柄

HINSTANCE pinstance=NULL;//钩子模块句柄

UINT mouseclickl=0;//记录鼠标左键单击次数的变量

UINT mouseclickr=0;//记录鼠标右键单击次数

#pragma data_seg()

extern C int APIENTRY

DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)

{ if(dwReason== DLL_PROCESS_ATTACH)

{……//省略部分机器生成代码

new CDynLinkLibrary(SpyDLL);

pinstance=hInstance;//取得模块句柄

}

……;

}

extern C LRESULT CALLBACK mouseproc(int code, WPARAM wparam,LPARAM lparam)//钩子处理函

{

if(code<0)//若code〈0，则直接调用callnexthookex返回

return CallNextHookEx(hhook, code, wparam, lparam);

if(wparam==WM_LBUTTONDOWN)

{ mouseclickl++;//记录鼠标左键单击次数}

if(wparam==WM_RBUTTONDOWN)

{ mouseclickr++;//记录鼠标右键单击次数}

return CallNextHookEx(hhook, code, wparam,lparam);

}

extern C bool WINAPI starthook()//启动钩子函数

{

hhook=SetWindowsHookEx(WH_MOUSE,mouseproc,pinstance,0);//挂上钩子

if(hhook!=NULL)

return true;

else return false;

}

extern C bool WINAPI stophook()//撤销钩子函数

{ return UnhookWindowsHookEx(hhook);//撤销钩子}

extern C int WINAPI getresultl()//返回鼠标左键单击次数

{ return mouseclickl;}

extern C int WINAPI getresultr()//返回鼠标右键单击次数

{ return mouseclickr;}

（5）修改spy.def程序代码如下:

exports

stophook@2

starthook@1

getresultl@3

getresultr@4

(6)编译project，生成spy.dll文件和spy.lib文件。 2．建立使用钩子的应用程序

（1）生成一个单文档的可执行文件（exe）的project。

（2）修改资源中的主选单，增加一个选单项“监控”，下有三个子选单项，分别为“启动”、“撤销”和“取出”。

（3）在project中加入spy.lib文件。

（4）分别修改“启动”、“撤销”和“取出”选单项的command响应函数如下：

#include E:\DevStudio\MyProjects\spy\hook.h//路径可不同

void CMainFrame::OnMenuitem32771()//“启动”选单项的响应函数

{ starthook();}

void CMainFrame::OnMenuitem32772()//“撤销”选单项的响应函数

{ stophook();}

void CMainFrame::OnMenuitem32773()//“取出”选单项的响应函数

{ int resultl=getresultl();

int resultr=getresultr();

char buffer[80];

wsprintf(buffer,在程序运行期间，你共单击鼠标左键%d次，右键%d次!,resultl,resultr);

::MessageBox(this->m_hWnd,buffer,message,MB_OK);

}

编译这个project，并把spy.dll放到生成的可执行文件目录下，便可运行程序。运行时，选择“监控”选单中的“启动”选单项，钩子便开始工作，监视鼠标的活动情况；选择“撤销”选单项，系统便撤销钩子；选择“取出”选单项，程序便报告在监控期间，用户分别单击鼠标左键和右键的次数。

二、消息钩子的VB中的Hook技术应用

Hook简介

Hook这个东西有时令人又爱又怕，Hook是用来拦截系统某些讯息之用，例如说，我们想

让系统不管在什么地方只要按个Ctl-B便执行NotePad，或许您会使用Form的KeyPreview

，设定为True，但在其他Process中按Ctl-B呢？那就没有用，这是就得设一个Keyboard

Hook来拦截所有Key in的键；再如：MouseMove的Event只在该Form或Control上有效，如果希望在Form的外面也能得知Mouse Move的讯息，那只好使用Mouse Hook来栏截Mouse

的讯息。再如：您想记录方才使用者的所有键盘动作或Mosue动作，以便录巨集，那就

使用JournalRecordHook，如果想停止所有Mosue键盘的动作，而放(执行)巨集，那就

使用JournalPlayBack Hook；Hook呢，可以是整个系统为范围(Remote Hook)，即其他

Process的动作您也可以拦截，也可以是LocalHook，它的拦截范围只有Process本身。

Remote Hook的Hook Function要在.Dll之中，Local Hook则在.Bas中。

在VB如何设定Hook呢？使用SetWindowsHookEx()

Declare Function SetWindowsHookEx Lib'user32' Alias'SetWindowsHookExA' _

(ByVal idHook As Long， _

ByVal lpfn As Long， _

ByVal hmod As Long， _

ByVal dwThreadId As Long) As Long

idHook代表是何种Hook，有以下几种

Public Const WH_CALLWNDPROC= 4

Public Const WH_CALLWNDPROCRET= 12

Public Const WH_CBT= 5

Public Const WH_DEBUG= 9

Public Const WH_FOREGROUNDIDLE= 11

Public Const WH_GETMESSAGE= 3

Public Const WH_HARDWARE= 8

Public Const WH_JOURNALPLAYBACK= 1

Public Const WH_JOURNALRECORD= 0

Public Const WH_KEYBOARD= 2

Public Const WH_MOUSE= 7

Public Const WH_MSGFILTER=(-1)

Public Const WH_SHELL= 10

Public Const WH_SYSMSGFILTER= 6

WH_CALLWNDPROC当调用SendMessage时

WH_CALLWNDPROCRET当SendMessage的调用返回时

WH_GETMESSAGE当调用GetMessage或 PeekMessage时

WH_KEYBOARD当调用GetMessage或 PeekMessage来从消息队列中查询WM_KEYUP或 WM_KEYDOWN消息时

WH_MOUSE当调用GetMessage或 PeekMessage来从消息队列中查询鼠标事件消息时

WH_HARDWARE当调用GetMessage或 PeekMessage来从消息队列种查询非鼠标、键盘消息时

WH_MSGFILTER当对话框、菜单或滚动条要处理一个消息时。该钩子是局部的。它时为那些有自己的消息处理过程的控件对象设计的。

WH_SYSMSGFILTER和WH_MSGFILTER一样，只不过是系统范围的

WH_JOURNALRECORD当WINDOWS从硬件队列中获得消息时

WH_JOURNALPLAYBACK当一个事件从系统的硬件输入队列中被请求时

WH_SHELL当关于WINDOWS外壳事件发生时，譬如任务条需要重画它的按钮.

WH_CBT当基于计算机的训练(CBT)事件发生时

WH_FOREGROUNDIDLE由WINDOWS自己使用，一般的应用程序很少使用

WH_DEBUG用来给钩子函数除错

lpfn代表Hook Function所在的Address，这是一个CallBack Fucnction，当挂上某个

Hook时，我们便得定义一个Function来当作某个讯息产生时，来处理它的Function

，这个Hook Function有一定的叁数格式

Private Function HookFunc(ByVal ncode As Long， _

ByVal wParam As Long， _

ByVal lParam As Long) As Long

nCode代表是什么请况之下所产生的Hook，随Hook的不同而有不同组的可能值

wParam lParam传回值则随Hook的种类和nCode的值之不同而不同。

因这个叁数是一个 Function的Address所以我们固定将Hook Function放在.Bas中，

并以AddressOf HookFunc传入。至于Hook Function的名称我们可以任意给定，不一

定叫 HookFunc

hmod代表.DLL的hInstance，如果是Local Hook，该值可以是Null(VB中可传0进去)，

而如果是Remote Hook，则可以使用GetModuleHandle('.dll名称')来传入。

dwThreadId代表执行这个Hook的ThreadId，如果不设定是那个Thread来做，则传0(所以

一般来说，Remote Hook传0进去)，而VB的Local Hook一般可传App.ThreadId进去

值回值如果SetWindowsHookEx()成功，它会传回一个值，代表目前的Hook的Handle，

这个值要记录下来。

因为A程式可以有一个System Hook(Remote Hook)，如KeyBoard Hook，而B程式也来设一

个Remote的KeyBoard Hook，那么到底KeyBoard的讯息谁所拦截？答案是，最后的那一个

所拦截，也就是说A先做keyboard Hook，而后B才做，那讯息被B拦截，那A呢？就看B的

Hook Function如何做。如果B想让A的Hook Function也得这个讯息，那B就得呼叫

CallNextHookEx()将这讯息Pass给A，于是产生Hook的一个连线。如果B中不想Pass这讯息

给A，那就不要呼叫CallNextHookEx()。

Declare Function CallNextHookEx Lib'user32' _

(ByVal hHook As Long， _

ByVal ncode As Long， _

ByVal wParam As Long， _

lParam As Any) As Long

hHook值是SetWindowsHookEx()的传回值，nCode， wParam， lParam则是Hook Procedure

中的三个叁数。

最后是将这Hook去除掉，请呼叫UnHookWindowHookEx()

Declare FunctionUnhookWindowsHookExLib'user32'(ByVal hHook As Long) As Long

hHook便是SetWindowsHookEx()的传回值。此时，以上例来说，B程式结束Hook，则换A可

以直接拦截讯息。

KeyBoard Hook的范例

Hook Function的三个叁数

nCode wParam lParam传回值

HC_ACTION表按键Virtual Key与WM_KEYDOWN同若讯息要被处理传0

或反之传1

HC_NOREMOVE

Public hHook As Long

Public Sub UnHookKBD()

If hnexthookproc&lt；&gt； 0 Then

UnhookWindowsHookExhHook

hHook= 0

End If

End Sub

Public Function EnableKBDHook()

If hHook&lt；&gt； 0 Then

Exit Function

End If

hHook= SetWindowsHookEx(WH_KEYBOARD， AddressOf MyKBHFunc， App.hInstance， App.ThreadID)

End Function

Public Function MyKBHFunc(ByVal iCode As Long， ByVal wParam As Long， ByVal lParam As Long) As Long

MyKBHFunc= 0'表示要处理这个讯息

If wParam= vbKeySnapshot Then'侦测有没有按到PrintScreen键

MyKBHFunc= 1'在这个Hook便吃掉这个讯息

End If

Call CallNextHookEx(hHook， iCode， wParam， lParam)'传给下一个Hook

End Function

只要将上面代码放在VB的模块中，用标准VB程序就可以了，当运行该程序后，就能拦截所有键盘操作。

三、系统钩子是什么

一、介绍

本文将讨论在.NET应用程序中全局系统钩子的使用。为此，我开发了一个可重用的类库并创建一个相应的示例程序（见下图）。

你可能注意到另外的关于使用系统钩子的文章。本文与之类似但是有重要的差别。这篇文章将讨论在.NET中使用全局系统钩子，而其它文章仅讨论本地系统钩子。这些思想是类似的，但是实现要求是不同的。

二、背景

如果你对Windows系统钩子的概念不熟悉，让我作一下简短的

・一个系统钩子允许你插入一个回调函数-它拦截某些Windows消息(例如，鼠标相联系的消息)。

・一个本地系统钩子是一个系统钩子-它仅在指定的消息由一个单一线程处理时被调用。

・一个全局系统钩子是一个系统钩子-它当指定的消息被任何应用程序在整个系统上所处理时被调用。

已有若干好文章来介绍系统钩子概念。在此，不是为了重新收集这些介绍性的信息，我只是简单地请读者参考下面有关系统钩子的一些背景资料文章。如果你对系统钩子概念很熟悉，那么你能够从本文中得到你能够得到的任何东西。

・关于MSDN库中的钩子知识。

・Dino Esposito的《Cutting Edge-Windows Hooks in the.NET Framework》。

・Don Kackman的《在C#中应用钩子》。

本文中我们要讨论的是扩展这个信息来创建一个全局系统钩子-它能被.NET类所使用。我们将用C#和一个DLL和非托管C++来开发一个类库-它们一起将完成这个目标。

三、使用代码

在我们深入开发这个库之前，让我们快速看一下我们的目标。在本文中，我们将开发一个类库-它安装全局系统钩子并且暴露这些由钩子处理的事件，作为我们的钩子类的一个.NET事件。为了说明这个系统钩子类的用法，我们将在一个用C#编写的Windows表单应用程序中创建一个鼠标事件钩子和一个键盘事件钩子。

这些类库能用于创建任何类型的系统钩子，其中有两个预编译的钩子-MouseHook和KeyboardHook。我们也已经包含了这些类的特定版本，分别称为MouseHookExt和KeyboardHookExt。根据这些类所设置的模型，你能容易构建系统钩子-针对Win32 API中任何15种钩子事件类型中的任何一种。另外，这个完整的类库中还有一个编译的HTML帮助文件-它把这些类归档化。请确信你看了这个帮助文件-如果你决定在你的应用程序中使用这个库的话。

MouseHook类的用法和生命周期相当简单。首先，我们创建MouseHook类的一个实例。

mouseHook= new MouseHook();//mouseHook是一个成员变量

接下来，我们把MouseEvent事件绑定到一个类层次的方法上。

mouseHook.MouseEvent+=new MouseHook.MouseEventHandler(mouseHook_MouseEvent);

//...

private void mouseHook_MouseEvent(MouseEvents mEvent, int x, int y){

string msg=string.Format("鼠标事件:{0}:({1},{2}).",mEvent.ToString(),x,y);

AddText(msg);//增加消息到文本框

}

为开始收到鼠标事件，简单地安装下面的钩子即可。

mouseHook.InstallHook();

为停止接收事件，只需简单地卸载这个钩子。

mouseHook.UninstallHook();

你也可以调用Dispose来卸载这个钩子。

在你的应用程序退出时，卸载这个钩子是很重要的。让系统钩子一直安装着将减慢系统中的所有的应用程序的消息处理。它甚至能够使一个或多个进程变得很不稳定。因此，请确保在你使用完钩子时一定要移去你的系统钩子。我们确定在我们的示例应用程序会移去该系统钩子-通过在Form的Dispose方法中添加一个Dispose调用。

protected override void Dispose(bool disposing){

if(disposing){

if(mouseHook!= null){

mouseHook.Dispose();

mouseHook= null;

}

//...

}

}

使用该类库的情况就是如此。该类库中有两个系统钩子类并且相当容易扩充。

四、构建库

这个库共有两个主要组件。第一部分是一个C#类库-你可以直接使用于你的应用程序中。该类库，反过来，在内部使用一个非托管的C++ DLL来直接管理系统钩子。我们将首先讨论开发该C++部分。接下来，我们将讨论怎么在C#中使用这个库来构建一个通用的钩子类。就象我们讨论C++/C#交互一样，我们将特别注意C++方法和数据类型是怎样映射到.NET方法和数据类型的。

你可能想知道为什么我们需要两个库，特别是一个非托管的C++ DLL。你还可能注意到在本文的背景一节中提到的两篇参考文章，其中并没有使用任何非托管的代码。为此，我的回答是，"对!这正是我写这篇文章的原因"。当你思考系统钩子是怎样实际地实现它们的功能时，我们需要非托管的代码是十分重要的。为了使一个全局的系统钩子能够工作，Windows把你的DLL插入到每个正在运行的进程的进程空间中。既然大多数进程不是.NET进程，所以，它们不能直接执行.NET装配集。我们需要一种非托管的代码代理- Windows可以把它插入到所有将要被钩住的进程中。

首先是提供一种机制来把一个.NET代理传递到我们的C++库。这样，我们用C++语言定义下列函数(SetUserHookCallback)和函数指针(HookProc)。

int SetUserHookCallback(HookProc userProc, UINT hookID)

typedef void(CALLBACK*HookProc)(int code, WPARAM w, LPARAM l)

SetUserHookCallback的第二个参数是钩子类型-这个函数指针将使用它。现在，我们必须用C#来定义相应的方法和代理以使用这段代码。下面是我们怎样把它映射到C#。

private static extern SetCallBackResults

SetUserHookCallback(HookProcessedHandler hookCallback, HookTypes hookType)

protected delegate void HookProcessedHandler(int code, UIntPtr wparam, IntPtr lparam)

public enum HookTypes{

JournalRecord= 0,

JournalPlayback= 1,

//...

KeyboardLL= 13,

MouseLL= 14

};

首先,我们使用DllImport属性导入SetUserHookCallback函数，作为我们的抽象基钩子类SystemHook的一个静态的外部的方法。为此，我们必须映射一些外部数据类型。首先，我们必须创建一个代理作为我们的函数指针。这是通过定义上面的HookProcessHandler来实现的。我们需要一个函数，它的C++签名为(int,WPARAM,LPARAM)。在Visual Studio.NET C++编译器中，int与C#中是一样的。也就是说，在C++与C#中int就是Int32。事情并不总是这样。一些编译器把C++ int作为Int16对待。我们坚持使用Visual Studio.NET C++编译器来实现这个工程，因此，我们不必担心编译器差别所带来的另外的定义。

接下来，我们需要用C#传递WPARAM和LPARAM值。这些确实是指针，它们分别指向C++的UINT和LONG值。用C#来说，它们是指向uint和int的指针。如果你还不确定什么是WPARAM，你可以通过在C++代码中单击右键来查询它，并且选择"Go to definition"。这将会引导你到在windef.h中的定义。

//从windef.h:

typedef UINT_PTR WPARAM;

typedef LONG_PTR LPARAM;

因此，我们选择System.UIntPtr和System.IntPtr作为我们的变量类型-它们分别相应于WPARAM和LPARAM类型，当它们使用在C#中时。

现在，让我们看一下钩子基类是怎样使用这些导入的方法来传递一个回叫函数(代理)到C++中-它允许C++库直接调用你的系统钩子类的实例。首先，在构造器中，SystemHook类创建一个到私有方法InternalHookCallback的代理-它匹配HookProcessedHandler代理签名。然后，它把这个代理和它的HookType传递到C++库以使用SetUserHookCallback方法来注册该回叫函数，如上面所讨论的。下面是其代码实现：

public SystemHook(HookTypes type){

_type= type;

_processHandler= new HookProcessedHandler(InternalHookCallback);

SetUserHookCallback(_processHandler, _type);

}

InternalHookCallback的实现相当简单。InternalHookCallback在用一个catch-all try/catch块包装它的同时仅传递到抽象方法HookCallback的调用。这将简化在派生类中的实现并且保护C++代码。记住，一旦一切都准备妥当，这个C++钩子就会直接调用这个方法。

[MethodImpl(MethodImplOptions.NoInlining)]

private void InternalHookCallback(int code, UIntPtr wparam, IntPtr lparam){

try{ HookCallback(code, wparam, lparam);}

catch{}

}

我们已增加了一个方法实现属性-它告诉编译器不要内联这个方法。这不是可选的。至少，在我添加try/catch之前是需要的。看起来，由于某些原因，编译器在试图内联这个方法-这将给包装它的代理带来各种麻烦。然后，C++层将回叫，而该应用程序将会崩溃。

现在，让我们看一下一个派生类是怎样用一个特定的HookType来接收和处理钩子事件。下面是虚拟的MouseHook类的HookCallback方法实现：

protected override void HookCallback(int code, UIntPtr wparam, IntPtr lparam){

if(MouseEvent== null){ return;}

int x= 0, y= 0;

MouseEvents mEvent=(MouseEvents)wparam.ToUInt32();

switch(mEvent){

case MouseEvents.LeftButtonDown:

GetMousePosition(wparam, lparam, ref x, ref y);

break;

//...

}

MouseEvent(mEvent, new Point(x, y));

}

首先，注意这个类定义一个事件MouseEvent-该类在收到一个钩子事件时激发这个事件。这个类在激发它的事件之前，把数据从WPARAM和 LPARAM类型转换成.NET中有意义的鼠标事件数据。这样可以使得类的消费者免于担心解释这些数据结构。这个类使用导入的 GetMousePosition函数-我们在C++ DLL中定义的用来转换这些值。为此，请看下面几段的讨论。

在这个方法中，我们检查是否有人在听这一个事件。如果没有，不必继续处理这一事件。然后，我们把WPARAM转换成一个MouseEvents枚举类型。我们已小心地构造了MouseEvents枚举来准确匹配它们在C++中相应的常数。这允许我们简单地把指针的值转换成枚举类型。但是要注意，这种转换即使在WPARAM的值不匹配一个枚举值的情况下也会成功。 mEvent的值将仅是未定义的（不是null，只是不在枚举值范围之内）。为此，请详细分析System.Enum.IsDefined方法。

接下来，在确定我们收到的事件类型后，该类激活这个事件，并且通知消费者鼠标事件的类型及在该事件过程中鼠标的位置。

最后注意，有关转换WPARAM和LPARAM值：对于每个类型的事件，这些变量的值和意思是不同的。因此，在每一种钩子类型中，我们必须区别地解释这些值。我选择用C++实现这种转换，而不是尽量用C#来模仿复杂的C++结构和指针。例如，前面的类就使用了一个叫作GetMousePosition的 C++函数。下面是C++ DLL中的这个方法：

bool GetMousePosition(WPARAM wparam, LPARAM lparam, int amp; x, int amp; y){

MOUSEHOOKSTRUCT* pMouseStruct=(MOUSEHOOKSTRUCT*)lparam;

x= pMouseStruct->pt.x;

y= pMouseStruct->pt.y;

return true;

}

不是尽量映射MOUSEHOOKSTRUCT结构指针到C#，我们简单地暂时把它回传到C++层以提取我们需要的值。注意，因为我们需要从这个调用中返回一些值，我们把我们的整数作为参考变量传递。这直接映射到C#中的int*。但是，我们可以重载这个行为，通过选择正确的签名来导入这个方法。

private static extern bool InternalGetMousePosition(UIntPtr wparam,IntPtr lparam, ref int x, ref int y)

通过把integer参数定义为ref int，我们得到通过C++参照传递给我们的值。如果我们想要的话，我们还可以使用out int。

五、限制

一些钩子类型并不适合实现全局钩子。我当前正在考虑解决办法-它将允许使用受限制的钩子类型。到目前为止，不要把这些类型添加回该库中，因为它们将导致应用程序的失败(经常是系统范围的灾难性失败)。下一节将集中讨论这些限制背后的原因和解决办法。

HookTypes.CallWindowProcedure

HookTypes.CallWindowProret

HookTypes.ComputerBasedTraining

HookTypes.Debug

HookTypes.ForegroundIdle

HookTypes.JournalRecord

HookTypes.JournalPlayback

HookTypes.GetMessage

HookTypes.SystemMessageFilter

六、两种类型的钩子

在本节中，我将尽量解释为什么一些钩子类型被限制在一定的范畴内而另外一些则不受限制。如果我使用有点偏差术语的话，请原谅我。我还没有找到任何有关这部分题目的文档，因此，我编造了我自己的词汇。另外，如果你认为我根本就不对，请告诉我好了。

当Windows调用传递到SetWindowsHookEx()的回调函数时它们会因不同类型的钩子而被区别调用。基本上有两种情况：切换执行上下文的钩子和不切换执行上下文的钩子。用另一种方式说，也就是，在放钩子的应用程序进程空间执行钩子回调函数的情况和在被钩住的应用程序进程空间执行钩子回调函数的情况。

钩子类型例如鼠标和键盘钩子都是在被Windows调用之前切换上下文的。整个过程大致如下：

1.应用程序X拥有焦点并执行。

2.用户按下一个键。

3. Windows从应用程序X接管上下文并把执行上下文切换到放钩子的应用程序。

4. Windows用放钩子的应用程序进程空间中的键消息参数调用钩子回调函数。

5. Windows从放钩子的应用程序接管上下文并把执行上下文切换回应用程序X。

6. Windows把消息放进应用程序X的消息排队。

7.稍微一会儿之后，当应用程序X执行时，它从自己的消息排队中取出消息并且调用它的内部按键（或松开或按下）处理器。

8.应用程序X继续执行...

例如CBT钩子(window创建，等等。)的钩子类型并不切换上下文。对于这些类型的钩子，过程大致如下：

1.应用程序X拥有焦点并执行。

2.应用程序X创建一个窗口。

3. Windows用在应用程序X进程空间中的CBT事件消息参数调用钩子回调函数。

4.应用程序X继续执行...

这应该说明了为什么某种类型的钩子能够用这个库结构工作而一些却不能。记住，这正是该库要做的。在上面第4步和第3步之后，分别插入下列步骤：

1. Windows调用钩子回调函数。

2.目标回调函数在非托管的DLL中执行。

3.目标回调函数查找它的相应托管的调用代理。

4.托管代理被以适当的参数执行。

5.目标回调函数返回并执行相应于指定消息的钩子处理。

第三步和第四步因非切换钩子类型而注定失败。第三步将失败，因为相应的托管回调函数不会为该应用程序而设置。记住，这个DLL使用全局变量来跟踪这些托管代理并且该钩子DLL被加载到每一个进程空间。但是这个值仅在放钩子的应用程序进程空间中设置。对于另外其它情况，它们全部为null。

Tim Sylvester在他的《Other hook types》一文中指出，使用一个共享内存区段将会解决这个问题。这是真实的，但是也如Tim所指出的，那些托管代理地址对于除了放钩子的应用程序之外的任何进程是无意义的。这意味着，它们是无意义的并且不能在回调函数的执行过程中调用。那样会有麻烦的。

因此，为了把这些回调函数使用于不执行上下文切换的钩子类型，你需要某种进程间的通讯。

我已经试验过这种思想-使用非托管的DLL钩子回调函数中的进程外COM对象进行IPC。如果你能使这种方法工作，我将很高兴了解到这点。至于我的尝试，结果并不理想。基本原因是很难针对各种进程和它们的线程(CoInitialize(NULL))而正确地初始化COM单元。这是一个在你可以使用 COM对象之前的基本要求。

我不怀疑，一定有办法来解决这个问题。但是我还没有试用过它们，因为我认为它们仅有有限的用处。例如，CBT钩子可以让你取消一个窗口创建，如果你希望的话。可以想像，为使这能够工作将会发生什么。

1.钩子回调函数开始执行。

2.调用非托管的钩子DLL中的相应的钩子回调函数。

3.执行必须被路由回到主钩子应用程序。

4.该应用程序必须决定是否允许这一创建。

5.调用必须被路由回仍旧在运行中的钩子回调函数。

6.在非托管的钩子DLL中的钩子回调函数从主钩子应用程序接收到要采取的行动。

7.在非托管的钩子DLL中的钩子回调函数针对CBT钩子调用采取适当的行动。

8.完成钩子回调函数的执行。

这不是不可能的，但是不算好的。我希望这会消除在该库中的围绕被允许的和受限制的钩子类型所带来的神秘。

七、其它

・库文档：我们已经包含了有关ManagedHooks类库的比较完整的代码文档。当以"Documentation"构建配置进行编译时，这被经由Visual Studio.NET转换成标准帮助XML。最后，我们已使用NDoc来把它转换成编译的HTML帮助(CHM)。你可以看这个帮助文件，只需简单地在该方案的解决方案资源管理器中点击Hooks.chm文件或通过查找与该文相关的可下载的ZIP文件。

・增强的智能感知：如果你不熟悉Visual Studio.NET怎样使用编译的XML文件(pre-NDoc output)来为参考库的工程增强智能感知，那么让我简单地介绍一下。如果你决定在你的应用程序中使用这个类库，你可以考虑复制该库的一个稳定构建版本到你想参考它的位置。同时，还要把XML文档文件(SystemHooks\ManagedHooks\bin\Debug\Kennedy.ManagedHooks.xml)复制到相同的位置。当你添加一个参考到该库时，Visual Studio.NET将自动地读该文件并使用它来添加智能感知文档。这是很有用的，特别是对于象这样的第三方库。

・单元测试：我相信，所有的库都应有与之相应的单元测试。既然我是一家公司（主要负责针对.NET环境软件的单元测试）的合伙人和软件工程师，任何人不会对此感到惊讶。因而，你将会在名为ManagedHooksTests的解决方案中找到一个单元测试工程。为了运行该单元测试，你需要下载和安装 HarnessIt-这个下载是我们的商业单元测试软件的一个自由的试用版本。在该单元测试中，我对这给予了特殊的注意-在此处，方法的无效参数可能导致 C++内存异常的发生。尽管这个库是相当简单的，但该单元测试确实能够帮助我在一些更为微妙的情况下发现一些错误。

・非托管的/托管的调试：有关混合解决方案（例如，本文的托管的和非托管的代码）最为技巧的地方之一是调试问题。如果你想单步调试该C++代码或在C++代码中设置断点，你必须启动非托管的调试。这是一个Visual Studio.NET中的工程设置。注意，你可以非常顺利地单步调试托管的和非托管的层，但是，在调试过程中，非托管的调试确实严重地减慢应用程序的装载时间和执行速度。

八、最后警告

很明显，系统钩子相当有力量；然而，使用这种力量应该是有责任性的。在系统钩子出了问题时，它们不仅仅垮掉你的应用程序。它们可以垮掉在你的当前系统中运行的每个应用程序。但是到这种程度的可能性一般是很小的。尽管如此，在使用系统钩子时，你还是需要再三检查你的代码。

我发现了一项可以用来开发应用程序的有用的技术-它使用系统钩子来在微软的虚拟PC上安装你的喜爱的开发操作系统的一个拷贝和Visual Studio.NET。然后，你就可以在此虚拟的环境中开发你的应用程序。用这种方式，当你的钩子应用程序出现错误时，它们将仅退出你的操作系统的虚拟实例而不是你的真正的操作系统。我已经不得不重启动我的真正的OS-在这个虚拟OS由于一个钩子错误崩溃时，但是这并不经常。