Delphi动态事件深入分析

[delphi] view plain copy

 

 print?

1. 首先做一个窗体如下  
2. 然后单元中如下代码：  
3. 在implementation下面声明两个方法如下：  
4. //外部方法，只声明一个参数，此时按照标准的对象内部事件方法TNotifyEvent声明,此声明中，Sender则对应为产生该事件的对象指针。  
5. procedure ExtClick1(Sender: TObject);  
6. begin  
7.   {asm 
8.     mov eax,[edx+8] 
9.     call showmessage 
10.   end; }  
11.   showmessage(TComponent(Sender).Name);  
12. end;  
13. //外部方法，声明两个参数,用来证明，对象在调用时候会传递一个Self指针，此时我们假设Frm是通过类对象传递过来的Self指针，而Sender为产生该事件的对象指针  
14. procedure ExtClick(Frm: TObject;Sender: TObject);  
15. begin  
16.   {asm 
17.     mov eax,[edx+8] 
18.     call showmessage 
19.   end; }  
20.   showmessage(TComponent(Sender).Name);  
21.   if Frm is TForm then  
22.     TForm(Frm).Close  
23. end;  
24. //然后在 ‘指定调用’按扭事件中写代码：  
25. procedure TForm1.Button1Click(Sender: TObject);  
26. begin  
27.    showmessage(TComponent(Sender).Name);  
28. end;  
29. //很显然运行的时候，点该按扭得到的是返回一个 消息内容为 ‘Button1’的对话框，这是调用Form1类的对象事件触发的方法。  
30. //在调用 ‘调用Form类外部方法触发事件’ Click事件中写  
31. procedure TForm1.Button2Click(Sender: TObject);  
32. var  
33.   ExtClickEvent: TNotifyEvent;  
34. begin  
35.   integer(@ExtClickEvent) := integer(@ExtClick1);  
36. //将ExtClickEvent地址指针指向外部函数ExtClick1方法的地址  
37.   Button1.OnClick := ExtClickEvent;  
38. //将该地址赋值给 Button1的OnClick事件替换以前的OnClick事件  
39. end;  
40. //另一个按扭写代码如下：  
41. procedure TForm1.Button3Click(Sender: TObject);  
42. begin  
43.   Button1.OnClick := Button1Click;//还原为对象内触发事件函数  
44. end;  
45. 运行之后  
46. 点一下 ‘调用Form类外部方法触发事件’ ，然后在点 ‘指定调用’按扭，  
47. showmessage(TComponent(Sender).Name); 返回的值是 ‘Form1’，此时是否就已经说明了其第一个参数是否就是传递的一个Self指针呢。所以在调用Button.Click事件的时候传递过来的第一个参数为Form1内部的Self指针，而该指针是指向Form1的。此时，我们在该函数的  
48. Begin位置放下一个断点，程序运行时候，此处的断点为非可用的，如下图：  
49.    
50. 说明程序在Begin处根本没有处理其他任何代码，此时，将断点调到  
51. showmessage(TComponent(Sender).Name);然后点 按扭 程序运行到断点处停下  
52. 调出CPU View窗口查看代码如下  
53.    
54. 注意 EAX,EBX,EDX,ECX的值,首先一条是  
55. Mov  eax,[eax+$08] //该条指令将对象的Name属性值传递到Eax中  
56. Call   ShowMessage //此函数需要一个参数，Delphi的参数传递规则为EAX,EDX,ECX  
57. 如此可见，没有任何多余的处理，但是此时还不能证明Eax传递过来的就是类对象的Self指针  
58. 此时将 ‘调用Form类外部方法触发事件’ Click事件中代码的函数换成  
59. ExtClick  
60. 既将   integer(@ExtClickEvent) := integer(@ExtClick1);  
61. 换成   integer(@ExtClickEvent) := integer(@ExtClick);  
62. 然后重新重复上面的步骤，在ExtClick的Begin处下断点，程序运行到断点处停下，则说明  
63. 程序在Begin时候有代码执行，打开CPU View查看如下：  
64. 可见在Begin之后，ShowMessage函数之前，有两段代码如下：  
65. Push ebx     //保存Ebx的值  
66. Mov ebx,eax  //将Eax的值暂时存放到Ebx中  
67. 然后主要看下面的showmessage(TComponent(Sender).Name);一句  
68. 可见 其汇编代码如下：  
69. Mov  eax,[edx+$08]  
70. Call  ShowMessage  
71. 和以前相比 Mov  eax,[eax+$08] 变成了 Mov  eax,[edx+$08]  
72. 此时，然后运行，得到结果为TComponent(Sender).Name 的值为Button1  
73. 而下面的代码  
74. if Frm is TForm then  
75. TForm(Frm).Close;  
76. 则充分证明了EAX的值是 Form1，则说明了对象方法在调用的时候会传递一个隐含的Self指针，而该指针的值在EAX中.  
77. 由于Delphi中参数的传递为  
78. EAX  第一个参数  
79. EDX  第二个参数  
80. ECX  第三个参数  
81. 所以可知道，真正的触发事件的按扭对象存放在EDX中.  
82. 所以我们可以得到如下结论  
83. 在 按扭的单击事件中，  
84. TNotifyEvent = procedure(Sender: TObject) of object;  
85. 其真正的实体为procedure(当前声明引起的对象Self,Sender: TObject)  
86. 所以 Button.OnClick的时候，其实传递方式如下  
87. Button1.OnClick(Self,Sender);  
88. 其他事件方法等，依次类推.  
89. 然后根据该结论，则我们可以不在受  
90. 为Form中的某个控件对象指定事件方法的时候受到 Of Object 那个东西的限制，可以将事件方法指定到任何地方了。只要注意，该方法对应的参数要比其事件方法(Of Object)指定的方法多一个参数声明，则可  
91. 比如，此时，我们拿窗体关闭事件做文章：  
92. 新建一个按扭，写代码  
93. procedure TForm1.Button4Click(Sender: TObject);  
94. var  
95.   CloseEvent: TCloseEvent;  
96. begin  
97.   integer(@CloseEvent) := integer(@MyCloseEvent);  
98.   self.OnClose := CloseEvent;  
99. end;  
100. 窗体关闭的事件方法为  
101. TCloseEvent = procedure(Sender: TObject;Var action: TCloseAction) of Object;  
102. 从上面结论我们知道可以声明一个外部函数，该外部函数的参数要比TCloseEvent的参数多一个Self指针的，所以我们声明如下：  
103. procedure MyCloseEvent(Frm: TForm;Sender: TObject;var Action: TCloseAction);  
104. Frm则是外部在窗体关闭的时候，传递的隐含指针Self  
105. 该函数整体代码如下：  
106. procedure MyCloseEvent(Frm: TForm;Sender: TObject;var Action: TCloseAction);  
107. begin  
108.   showmessage(Frm.Name+'窗体外部方法调用，不允许关闭窗体！');  
109.   Action := caNone;  
110. end;  
111. 点一下，新建的按扭之后，看看是否还可以关闭窗体！！  
112. 通过汇编来处理  
113. procedure TForm1.SetEvent(Event: pointer);  
114. asm  
115.   push ebx                //保护Ebx  
116.   mov ebx,eax    //将当前的eax的值，先用ebx保存起来，eax中保存的为Form的开始地  
117.   mov eax,edx    //将Event指针的值给EAX  
118.   mov [ebx+$2d8],eax   //将Eax的值分别写进其高位和低位  
119.   mov eax,[edx+4]     
120.   mov [ebx+$2d4],eax  
121.   pop ebx  
122. end;  
123. // 由于前面我们已经证明了，在类之中的方法，其传递的时候，都会有一个隐含的参数Self，所以，该段汇编代码中我们就知道了Event参数对应应该是 Edx寄存器，而不是Eax寄存器了。然后，后面有[ebx+$2d8]这样的内容，这个是窗体 OnClose事件所在位置的地址。可以通过CpuView窗口查看得到，暂时没有想到如何通过指定一个事件名称来得到该事件在内存中的地址。如果这样的话，那么则可以写一个函数  
124. ReSetObjEvent(EventName: string;EventValue: pointer);  
125. 先通过EventName找到事件地址，然后再通过上面的则可以写出一个简单通俗易懂的公用函数了。  
126. 否则只能通过传递地址，根据改变地址中的值来修改事件函数的指向了。如下：  
127. 写一个专门用来重设置事件方法的函数如下：  
128. procedure ReSetObjEvent(OldEventAddress: Pointer;NewEventValue: pointer);  
129. var  
130.   gg: integer;  
131.   sd: pinteger;  
132. begin  
133.  sd := OldEvent;  
134.   gg := integer(NewEvent);  
135.   sd^:=gg;  
136. end;  
137. 其实也就是 改变存放事件方法指针的内存块的数据值，使其变成另一个值。  
138. 注意，参数一指定为存放旧事件方法指针的内存地址，所以他应该是一个指针的指针了。  
139.       参数二指定为事件方法指针值。  
140. 调用方法如下：  
141.  比如，指定窗体的 OnClose事件方法指针为窗体类外部定义的函数。  
142.   ReSetObjEvent(@(integer(@Form1.onClose)),@MyCloseEvent)  
143. 例如：  
144. procedure FrmClose(Frm: TForm;Sender: TObject;Var Action: TCloseAction);  
145. begin  
146.    showmessage('调用外部方法，不许关闭！');  
147.    action := canone;  
148. end;  
149. procedure TForm1.BitBtn1Click(Sender: TObject);  
150. begin  
151.   ReSetObjEvent(@(integer(@self.OnClose)),@frmClose);  
152. end;  
153.   
154. 续言：  
155.   以上在Delphi7下测试通过，至于2007下，我测试，也传递了一个隐含参数，但是该隐含参数不是Self  
156. 再论：  
157.   经过Cnpack的刘啸提醒之后，发现了Delphi7下测试通过，而2007下不通过的原因是在于D7下如下声明：  
158. procedure TForm1.Button4Click(Sender: TObject);  
159. var  
160.   CloseEvent: TCloseEvent;  
161. begin  
162.   integer(@CloseEvent) := integer(@MyCloseEvent);  
163.   self.OnClose := CloseEvent;  
164. end;  
165. 此时2007下该段程序运行不能通过而D7编译运行可以通过,实在确实是一个巧合了。  
166. 通过提示得知，TCloseEvent在Delphi中被称为对象方法，而对象方法  
167. 在 Delphi 中用 procedure(Sender: TObject) of object; 这种格式声明的 事件(Event) 类型实际上是同时包含有对象和函数的记录。我们可以把一个 TNotifyEvent 的变量强制转换成 TMethod：  
168. TMethod = record  
169.   Code, Data: Pointer;  
170. end;  
171. 例如我们声明了一个方法 MainForm.BtnClick 并将它赋值给 btn1.OnClick 事件，实际上是将 MainForm 对象和 BtnClick 方法地址分别作为 TMethod 结构的 Data 和 Code 成员赋值给 btn1.OnClick 事件属性。当 btn1 按钮调用这个 BtnClick 事件时，实际上是将 TMethod 结构的 Data 作为第一个参数去调用 Code 函数。  
172. 我们可以编写下面的代码：  
173. procedure MyClick(Self: TObject; Sender: TObject);  
174. begin  
175.   // 第一个参数是虚拟的  
176.   ShowMessage(Format('Self: %d, Sender: %s', [Integer(Self), Sender.ClassName]));  
177. end;  
178. procedure TForm1.FormCreate(Sender: TObject);  
179. var  
180.   M: TMethod;  
181. begin  
182.   M.Code := @MyClick;  
183.   M.Data := Pointer(325); // 随便取的数  
184.   btn1.OnClick := TNotifyEvent(M);  
185. end;  
186. 这样就可以将一个普通函数赋值给对象事件属性了。  
187. 我们再来看看 TLanguages.Create 的代码：  
188. constructor TLanguages.Create;  
189. type  
190.   TCallbackThunk = packed record  
191.     POPEDX: Byte;  
192.     MOVEAX: Byte;  
193.     SelfPtr: Pointer;  
194.     PUSHEAX: Byte;  
195.     PUSHEDX: Byte;  
196.     JMP: Byte;  
197.     JmpOffset: Integer;  
198.   end;  
199. var  
200.   Callback: TCallbackThunk;  
201. begin  
202.   inherited Create;  
203.   Callback.POPEDX := $5A;  
204.   Callback.MOVEAX := $B8;  
205.   Callback.SelfPtr := Self;  
206.   Callback.PUSHEAX := $50;  
207.   Callback.PUSHEDX := $52;  
208.   Callback.JMP     := $E9;  
209.   Callback.JmpOffset := Integer(@TLanguages.LocalesCallback) - Integer(@Callback.JMP) - 5;  
210.   EnumSystemLocales(TFNLocaleEnumProc(@Callback), LCID_SUPPORTED);  
211. end;  
212. 在 Win32 SDK 中可以查到 EnumSystemLocales 要求的回调格式是：  
213. BOOL CALLBACK EnumLocalesProc(  
214.     LPTSTR lpLocaleString         // pointer to locale identifier string  
215. );  
216. 而 SysUtils 中的方法声明：  
217.   TLanguages = class  
218.     ...  
219.     function LocalesCallback(LocaleID: PChar): Integer; stdcall;  
220.     ...  
221.   end;  
222. 显然，我们是无法将 LocalesCallback 这个方法直接传递给 EnumSystemLocales 的，因为 LocalesCallback 的函数形式声明实际上是：  
223. function LocalesCallback(Self: TLanguages; LocaleID: PChar): Integer; stdcall;  
224. 比 EnumLocalesProc 多出来一个参数。  
225. 所以在 TLanguages.Create 中，使用了 Callback 结构变量来生成一小段动态代码。这段代码是构造在堆栈中的（局部变量），转换成汇编是：  
226. prcoedure CallbackThunk;  
227. asm  
228.   // 取出 lpLocaleString 参数到 EDX 寄存器  
229.   // CALLBACK EnumLocalesProc 是 stdcall 调用，参数在堆栈中  
230.   POP EDX  
231.   // 将 Self 对象传给 EAX 寄存器  
232.   MOV EAX Self  
233.   // stdcall 调用，将 Self 作为第一个参数压栈  
234.   PUSH EAX  
235.   // 将 lpLocaleString 作为第二个参数压栈  
236.   PUSH EDX  
237.   // 用相对跳转指令跳转到 TLanguages.LocalesCallback 入口地址  
238.   JMP TLanguages.LocalesCallback  
239. end;  
240. 将 CallbackThunk 作为临时的回调函数传递给 EnumSystemLocales 是合法的。当回调被执行时，前面那小段代码动态修改了堆栈的内容，将本来只有一个参数的调用，变成了两个参数，从而实现了回调与对象方法的转换。  
241. 但是，正如 Passion 在前面提到的，由于这小块临时代码是放在堆栈中的，而 Win2003 的 DEP 限制了在堆栈中执行代码，导致事实上回调函数并没有被正确地调用。  
242. Borland 程序员也看到了这个问题，所以在 BDS 2006 中，这部分代码的实现修改成：  
243. var  
244.   FTempLanguages: TLanguages;  
245. function EnumLocalesCallback(LocaleID: PChar): Integer; stdcall;  
246. begin  
247.   Result := FTempLanguages.LocalesCallback(LocaleID);  
248. end;  
249. constructor TLanguages.Create;  
250. begin  
251.   inherited Create;  
252.   FTempLanguages := Self;  
253.   EnumSystemLocales(@EnumLocalesCallback, LCID_SUPPORTED);  
254. end;  
255. 通过声明一个临时变量和转换函数，来取代原来的方法，就不会有 DEP 冲突了。  
256. 附带说一下 Forms 单元中的 MakeObjectInstance。这个函数用来生成一块动态代码，将 Windows 的窗体消息处理过程转换为 Delphi 的对象方法调用。在 TWinControl 等需要有消息处理支持的地方用到。该函数也是采用了前面类似的方法，不过不同的是，由于这些转换调用是长期的，所以那些动态生成的代码被放到了标识为可执行的动态空间中了，所以在 Win2003 的 DEP 下仍然可以正常工作：  
257. function MakeObjectInstance(Method: TWndMethod): Pointer;  
258. var  
259.   ...  
260. begin  
261.   if InstFreeList = nil then  
262.   begin  
263.     Block := VirtualAlloc(nil, PageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);  
264.     ...  
265. end;  
266. 刘啸  
267. 例如我们声明了一个方法 MainForm.BtnClick 并将它赋值给 btn1.OnClick 事件，实际上是将 MainForm 对象和 BtnClick 方法地址分别作为 TMethod 结构的 Data 和 Code 成员赋值给 btn1.OnClick 事件属性。“当 btn1 按钮调用这个 BtnClick 事件时，实际上是将 TMethod 结构的 Data 作为第一个参数去调用 Code 函数。”  
268. 这里关于调用的似乎值得讨论一下。记得这个事件OnClick在被调用时是这么写的：  
269. if Assigned(FOnClick) then  
270.   FOnClick(Self);  
271. 第一个参数是调用时传入的是Button自身，也就是Button的Self，而不是原本这个Method里头的Data吧？  
272. 我的理解是，Method的Data只是用来说明这个方法属于哪个对象实例，但被调的时候似乎没发挥作用。所以自行捏造一个TMethod的data部分，然后给OnClick等赋值再调用也能成功。  
273. 周劲羽  
274. if Assigned(FOnClick) then  
275.   FOnClick(Self);  
276. 这里传入的 Self 是 TNotifyEvent 中的 Sender: TObject 参数，而作为对象方法的 OnClick，实际上需要两个参数，第一个隐藏的 Self 是 OnClick 方法所从属的对象，第二个才是 Sender。  
277. 比如 Button 调用 FOnClick 时，这个 FOnClick 指向的方法可能是从属于某个 Form 的 OnBtnClick。类自己是不保存对象实例的，直接调用 Form.OnBtnClick 时 Self 是 Form 这个实例，而通过 Button.FOnClick 调用到 Form.OnBtnClick 方法时，OnBtnClick 的 Self 从哪里来？当然就是用 TMethod.Data 传过去的喽。而这个 TMethod.Data 则是在赋值 Button.OnClick := Form.OnBtnClick 时的 Form 对象。  
278. FOnClick时传入的Self是作为Sender的，而BtnOnClick方法里头所引用的Self是Form实例，后者的Self应该是从Data里头来的。  
279. 由上可得到一个通用函数，用来动态设置对象事件:  
280. procedure ReSetObjEvent(OldEventAddr: pointer;NewEventValue: pointer;ReSetObject: TObject);  
281. begin  
282.  TMethod(OldEventAddr^).Code := NewEventValue;  
283.  TMethod(OldEventAddr^).Data := ReSetObject;  
284. end;  
285. 参数一： 指定为 存放事件指针的内存地址值的地址指针，所以为一个指针的指针  
286. 参数二： 指定为新的事件函数地址指针  
287. 参数三： 指定为重设事件的修改者,用来隐射对象方法的隐含参数Self  
288. 调用方法：  
289.   ReSetObjEvent(@integer(@self.OnClose),@MyCloseEvent,self);  
290. 例：  
291. procedure MyCloseEvent(ClassSend: TObject;Sender: TObject;var Action: TCloseAction );  
292. begin  
293.     action := canone;  
294.     showmessage(TComponent(Sender).Name+'触发,不许关闭');  
295.     showmessage(TComponent(ClassSend).Name);  
296. end;  
297. procedure TForm1.Button1Click(Sender: TObject);  
298. begin  
299.   ReSetObjEvent(@integer(@self.OnClose),@MyCloseEvent,self);  
300. end;