The communication call between the DLL and the EXE and the thread execution space of the callback function

There are many kinds of communication between DLL and EXE, this paper uses the method of callback function, this article will also study multi-threaded, multi-module case, the callback function where the thread, do not say, the first attached code:

The following is the DLL module, the DLL's project file:

[Delphi]View Plaincopy

2. Library Dllapp;
6. Uses
8. Windows
10. Sysutils,
12. Classes,
14. Dllclass in ' Dllclass.pas ';
18. {$R *.res}
24. var
26. Gdllserver:tdllserver;
30. function Addserver (adispatchfunc:tdispatchfunc): HRESULT; stdcall;
32. begin
34. Result: = error_invalid_function;
36. If not Assigned (gdllserver) Then
38. Exit;
40. Gdllserver.  Addserver (Adispatchfunc);
42. Result: = ERROR_SUCCESS;
44. end;
48. function Datadispatch (acommand:integer): HRESULT; stdcall;
50. begin
52. Result: = error_invalid_function;
54. Gdllserver.  Datadispatch (Acommand);
56. Result: = 0;
58. end;
62. function Dllinitialize:hresult;
64. begin
66. Result: = 1;
68. Gdllserver: = Tdllserver. Create;
70. Result: = ERROR_SUCCESS;
72. end;
76. function Dllfinalize:hresult;
78. begin
80. Result: = error_invalid_function;
82. Gdllserver.  Free;
84. Gdllserver: = nil;
86. Result: = ERROR_SUCCESS;
88. end;
92. Exports
94. Addserver,
96. Datadispatch,
98. Dllinitialize,
100. Dllfinalize;
104. Begin
106. End.

The type file in the DLL

[Delphi]View Plaincopy

2. Unit Dllclass;
6. Interface
10. Uses
12. Windows, Messages, sysutils, variants, Classes, Graphics, Controls, Forms,
14. Dialogs, Stdctrls;
20. Type
22. Tdispatchfunc = function (acommand:integer): Hresult;stdcall;
26. Type
28. Tdllserver = CLAss;
32. Tdllthread = Class (TThread)
34. Private
36. Fcount:integer;
38. Fdllserver:tdllserver;
40. Public
42. procedure Execute; override;
44. Public
46. constructor Create;
48. end;
52. Tdllserver = class
54. Private
56. Fdispatchfunc:tdispatchfunc;
58. Fdllthread:tdllthread;
60. Public
62. procedure Addserver (Adispatchfunc:tdispatchfunc);
64. procedure Datadispatch (Acommand:integer);
66. Public
68. constructor Create;
70. destructor Destroy;
72. end;
76. Implementation
80. {Tdllserver}
84. Save EXE's callback function pointer
86. Procedure Tdllserver.  Addserver (Adispatchfunc:tdispatchfunc);
88. Begin
90. Fdispatchfunc: = Adispatchfunc;
92. End
96. Constructor Tdllserver. Create;
98. Var
100. lthreadid:cardinal;
102. Begin
104. ///
106. Lthreadid: = GetCurrentThreadID;
108. ShowMessage (' dll,create: ' +inttostr (Lthreadid));
110. Fdllthread: = Tdllthread. Create;
112. Fdllthread.  Fdllserver: = self;
114. Fdllthread.  Resume;
116. End
120. DLL accepts EXE pass-through instruction, DLL leaves EXE to invoke an excuse
122. Procedure Tdllserver.  Datadispatch (Acommand:integer);
124. Var
126. lthreadid:cardinal;
128. Begin
130. If not Assigned (fdispatchfunc) Then
132. Exit;
134. Fdispatchfunc (Acommand);
136. Lthreadid: = GetCurrentThreadID;
138. ShowMessage (' Dll,datedispatch: ' +inttostr (Lthreadid));
140. End
144. destructor Tdllserver.  Destroy;
146. Begin
148. ////
150. End
154. {Tdllthread}
158. Constructor Tdllthread. Create;
160. Var
162. lthreadid:cardinal;
164. Begin
166. Fcount: = 0;
168. inherited Create (True);
170. End
174. The purpose of this function is to verify the execution thread of the callback function under different threads under different modules.
176. Procedure Tdllthread.  Execute;
178. Var
180. lthreadid:cardinal;
182. Begin
184. inherited;
186. While not Terminated do
188. begin
190. INC (Fcount);
192. if Fcount = 2 Then
194. begin
196. Lthreadid: = GetCurrentThreadID;
198. ShowMessage (' dll,thread--' +inttostr (Lthreadid));
200. end;
202. If Fcount = 5 Then
204. begin
206. if assigned (fdllserver) Then
208. begin
210. Fdllserver.  Fdispatchfunc (2);
212. end;
216. end;
218. Sleep (1000);
220. end;
222. End
226. End.

EXE's files

[C-sharp]View Plaincopy

2. Unit Execlass;
6. Interface
10. Uses
12. Windows, Messages, sysutils, variants, Classes, Graphics, Controls, Forms,
14. Dialogs, Stdctrls;
18. Type
20. Tdispatchfunc = function (Acommand:integer): Hresult;stdcall;
22. Tserverfunc = function (adispatchfunc:tdispatchfunc): Hresult;stdcall;
24. Tproc = Function:hresult;
28. Type
30. TForm2 = Class (Tform)
32. Button1:tbutton;
34. Memo1:tmemo;
36. Procedure Formdestroy (Sender:tobject);
38. Procedure Button1Click (Sender:tobject);
40. Procedure Formcreate (Sender:tobject);
42. Private
44. {Private declarations}
46. Fserverdispatch:tserverfunc; ///exe--->dll
48. Fdatadispatch:tdispatchfunc; ///exe--->dll
50. Fdllinitialize:tproc;
52. Fdllfinalize:tproc;
54. Public
56. {Public declarations}
58. End
62. Var
64. Form2:tform2;
66. Ghandlelibrary:thandle;
68. Gcount:integer;
72. Implementation
76. {$R *.DFM}
80. DLL--->exe, the callback function left for DLL calls
82. function Datadispatch (Acommand:integer): HRESULT; stdcall;
84. Var
86. lthreadid:cardinal;
88. Begin
90. Lthreadid: = GetCurrentThreadID;
92. ShowMessage (' EXE: ' +inttostr (Lthreadid));
94. End
98. Procedure Tform2.button1click (Sender:tobject);
100. Begin
102. INC (Gcount);
104. Fdatadispatch (Gcount);
106. End
110. Procedure Tform2.formdestroy (Sender:tobject);
112. Begin
114. Fdllfinalize;
116. Fserverdispatch: = nil;
118. Fdatadispatch: = nil;
120. Fdllinitialize: = nil;
122. Fdllfinalize: = nil;
124. FreeLibrary (ghandlelibrary);
126. End
130. Procedure Tform2.formcreate (Sender:tobject);
132. Var
134. lthreadid:cardinal;
136. Begin
138. Ghandlelibrary: = LoadLibrary (PChar (' DLLAPP.dll '));
140. @FDllInitialize: = GetProcAddress (ghandlelibrary, ' dllinitialize ');
142. @FDllFinalize: = GetProcAddress (ghandlelibrary, ' dllfinalize ');
144. @FServerDispatch: = GetProcAddress (ghandlelibrary, ' addserver ');
146. @FDataDispatch: = GetProcAddress (ghandlelibrary,' Datadispatch ');
148. Fdllinitialize;
150. Fserverdispatch (Datadispatch);
152. Lthreadid: = GetCurrentThreadID;
154. MEMO1.LINES.ADD (IntToStr (Lthreadid));
156. End
160. End.

1, the simple implementation of the DLL and the communication between the EXE, in fact, the use of the DLL's export function, first think of the DLL to pass the address of a callback function, for the DLL-oriented EXE communication. EXE DLL-oriented communication directly execute the DLL export function can be

2, this article is the most basic implementation, of course, the callback function, as well as the handler function of the DLL, can be implemented at the level of the packet, that is: define different packets, according to the command to execute different functions, so long as the export of a function, retain a callback function can achieve a large number of functions

3, on the thread execution space of the callback function, depending on the caller's thread, such as the callback EXE function in the DLL thread, the callback function is executed on the DLL thread. If it is the main thread that executes the callback, then the main thread. The above code Gdllclass creation process is the export function, so the main thread of Gdllclass is the main thread of EXE, they are in a threaded space

http://blog.csdn.net/procedure1984/article/details/3985127

The communication call between the DLL and the EXE and the thread execution space of the callback function