Delphi深入DLL编程
引言
相信有些计算机知识的朋友都应该听说过“DLL”。尤其是那些使用过windows操作系统的人，都应该有过多次重装系统的“悲惨”经历——无论再怎样小心，没有驱动损坏，没有病毒侵扰，仍然在使用（安装）了一段时间软件后，发现windows系统越来越庞大，操作越来越慢，还不时的出现曾经能使用的软件无法使用的情况，导致最终不得不重装系统。这种情况常常是由于dll文件的大量安装和冲突造成的。这一方面说明DLL的不足，另一方面也说明DLL的重要地位，以至我们无法杜绝它的使用。
DLL（动态链接库，Dynamic Link Library）简单来说是一种可通过调用执行的已编译的代码模块。DLL是windows系统的早期产物。当时的主要目的是为了减少应用程序对内存的使用。只有当某个函数或过程需要被使用时，才从硬盘调用它进入内存，一旦没有程序再调用该DLL了，才将其从内存中清除。光说整个windows系统，就包括了成百上千个dll 文件，有些dll文件的功能是比较专业（比如网络、数据库驱动）甚至可以不安装的。假如这些功能全部要包括在一个应用程序（Application program）里，windows将是一个数百M 大小的exe文件。这个简单的例子很容易解释DLL的作用，而调用DLL带来的性能损失则变得可被忽略不计。
多个应用程序调用同一个DLL，在内存里只有一个代码副本。而不会象静态编译的程序那样每一个都必须全部的被装入。装载DLL时，它将被映射到进程的地址空间，同时使用DLL的动态链接并非将库代码拷贝，而仅仅记录函数的入口点和接口。
同时DLL还能带来的共享的好处。一家公司开发的不同软件可能需要一些公用的函数过程，这些函数过程可能是直接的使用一些内部开发的DLL；一些常用的功能则可以直接使用windows的标准DLL，我们常说的windows API就是包含在windows几个公用DLL文件里的函数过程；理论上（如果不牵涉作者的版权），知道一个DLL的声明及作用（函数定义的输入参数及返回值），我们完全可以在不清楚其实现（算法或编译方式）的情况下直接使用它。
假如一个DLL中函数过程的算法得到了更新，BUG得到了修正，整个dll文件会得到升级。一般来说为了保证向下兼容，调用声明与返回结果应该保持不变。但实际上，即使是同一家开发的DLL，随着功能的改善，也很难保证某个调用执行完全不变。在使用其他人开发的DLL时这种糟糕情况更加的严重。比如我在一个绘图程序里使用了某著名图形软件商旧版本的DLL包，我所有的调用都是根据他发布的旧版的声明来执行的。假设用户安装了该软件商的一个新软件，导致其中部分DLL被更新升级，假如这些DLL已经有过改动，直接后果将是我的软件不再稳定甚至无法运行！不要轻视这种情况，事实上它是很普遍的，比如windows在修正BUG和升级过程中，就不断改动它包含的那些DLL。往往新版DLL 不是简单的增加新的函数过程，而是更换甚至取消了原有的声明，这时候我们再也无法保证所有程序都运行正常。
DLL除了上面提到的改善计算机资源利用率、增加开发效率、隐藏实现细节外，还可以包含数据和各种资源。比如开发一个软件的多国语言版，就可以使用DLL将依赖于语言的函数和资源分离出来，然后让各地的用户安装不同对应的DLL，以获取本地字符集的支持。再比如一个软件必须的图形、图标等资源，也可以直接放在dll文件中统一安装管理。
创建一个DLL
在进行后面的讲解之前，我想大家应该先清楚一个概念：例程声明的是一个指针变量，调用函数过程，其实是通过指针转入该函数过程的执行代码。
我们先尝试用Delphi来建立一个自己的DLL文件。这个DLL包含一个标准的目录删除（包含子目录及文件）函数。
建立DLL
通过Delphi建立一个DLL是很容易的。New一个新Project，选择DLL Wizard，然后会生成一个非常简单的单元。该单元不象一般的工程文件以program开始，而是以library 开始的。
该工程单元缺省引用了SysUtils、Classes两个单元。可以直接在该单元的uses之后，begin … end部分之前添加函数过程代码，也可以在工程中添加包含代码的单元，然后该单元将会被自动uses。
接下来是编写DLL例程的代码。如果是引用单元里的例程，需要通过声明时添加export 后缀引出。假如是直接写在library单元中的，则不必再写export了。
最后一步是在library单元的begin语句之上，uses部分及函数定义之下添加exports部分，并列举需要引出的例程名称。注意仅仅是名称，不包含procedure或function关键字，也不需要参数、返回值和后缀。
exports语句后的语法有三种形式（例程指具体的函数过程）：
exports例程名；
exports例程名 index 索引值；
exports例程名 name新名称；
索引值和新名称便于其他程序确定函数地址；也可以不指定，如果没有使用Index关键字，Delphi将按照exports后的顺序从1开始自动分配索引号。Exports后可跟多个例程，之间以逗号分隔。
编译，build最终的dll文件。
需注意的格式
为了保证生成的DLL能正确与C++等语言兼容，需要注意以下几点：
1、尽量使用简单类型或指针作为参数及返回值的类型。这里的简单类型是指C++的简单类型，所以string字符串类型最好转换成Pchar字符指针。直接使用string的DLL例程在Delphi开发的程序中调用是没有问题的（有资料指出需加入ShareMem做为第一单元以确保正确），但如果使用C++或其他语言开发的程序调用，则不能保证参数传递正确；
2、虽然过程是允许的，但是最好习惯全部写成函数。过程则返回执行正确与否的true、false；
3、对于参数的指示字比如const（只读）、out（只写）等等，为保证调用的兼容性，最好使用缺省方式（缺省var，即可读写的地址）；
4、使用stdcall声明后缀，以保证正确的异常处理。16位DLL无法通过这种方式处理异常，所以还得在例程最外层用Try … Except将异常处理掉；
5、一般不使用far后缀，除非为了保持与16位兼容。
范例代码
DLL工程单元：
library FileOperate;
uses
SysUtils,
Classes,
uDirectory in 'uDirectory.pas';
{$R .res}
exports
DeleteDir;
begin
end.
函数功能实现单元：
unit uDirectory;
interface
uses
Classes, SysUtils;
function DeleteDir(DirName: Pchar): boolean; export; stdcall;
implementation
function DeleteDir(DirName: Pchar): boolean;
var
FindFile: TSearchRec;
s: string;
begin
s := DirName;
if copy(s,length(s), 1) := '' then s := s + '';
if DirectoryExists(s) then
begin
if FindFirst(s + '.', faAnyFile, FindFile) = 0 then
begin
repeat
if FindFile.Attr = faDirectory then
begin
//文件则删除
DeleteFile(s + https://www.doczj.com/doc/b516875078.html,);
end
else
begin
//目录则嵌套自身
if (https://www.doczj.com/doc/b516875078.html,, '.') and (https://www.doczj.com/doc/b516875078.html, , '..') then
DeleteDir(Pchar(s + https://www.doczj.com/doc/b516875078.html,));
end;
until FindNext(FindFile) = 0;
FindCLose(FindFile);
end;
end;
Result = RemoveDir(s);
end;
end.
初始化及释放资源
Delphi中初始化有几种方法。一种是利用Unit的Initalization与Finalization这两个小节（不知道“单元小节”？你该先去恶补Delphi语法了）进行该单元中变量的初始化工作。注意，DLL虽然在内存中只有一个副本，但是例程隶属于调用者的不同进程空间。如果想初始化公共变量来达到多进程共享是不可行的，同时也要注意公共变量带来的冲突问题。
二是在library单元的begin … end部分进行DLL的初始化。假如想在DLL结束时有对应代码，则可以利用DLL自动创建的一个ExitProc过程变量，这是一个退出过程的指针。建立一个自己的过程，并将该过程的地址赋与ExitProc。因为ExitProc是DLL创建时就存在的，所以在begin … end部分就应该进行此步操作。同时建立一个临时指针变量保存最初的ExitProc值，在自己的退出过程中将ExitProc值赋回来。这样做是为了进行自己的退出操作后，能完成缺省的DLL退出操作（与在重载的Destory方法中inherated的意义是一样的，完成了自己的destory，还需要进行缺省的父类destory才完整）。
示例如下：
library MyDLL;
...
var
OldExitProc pointer; //公共变量，为的保存最初的ExitProc指针以便赋回
procedure MyExitProc;
begin
…//对应初始化的结束代码
ExitProc := OldExitProc; //自己的退出过程中要记住将ExitProc赋回
end;
...
begin
... //初始化代码
OldExitProc := ExitProc;
ExitProc := @MyExitProc;
end.
第三种方法和ExitProc类似，在System单元中预定义了一个指针变量DllProc（该方法需要引用 Windows单元）。在使用DLLProc时, 必须先写好一个具有以下原型的程序
procedure DLLHandler(dwReason: DWORD); stdcall;
并在library的begin..end.之间, 将这个DLLHandler程序的执行地址赋给DLLProc中, 这时就可以根据参数dwReason的值分别作出相应的处理。
示例如下：
library MyDLL;
...
procedure MyDLLHandler(dwReason DWORD);
begin
case dwReason of
DLL_Process_Attach: //进程进入时
DLL_Process_Detach: //进程退出时
DLL_Thread_Attach: //线程进入时
DLL_Thread_Detach: //线程退出时
end;
end;
...
begin
... 初始化代码
DLLProc := @MyDLLHandler;
MyDLLHandle(DLL_Process_Attach);
end.
可见，通过DLLProc 在处理多进程时比ExitProc更加强大和灵活。
静态（隐式）调用DLL
DLL已经有了，接下来我们看如何调用并调试它。普通的DLL是不需要注册的，但是要包含在windows搜索路径中才能被找到。搜索路径的顺序是：当前目录；Path路径；windows 目录;widows系统目录（system、system32）。
引入DLL例程的声明方法
在需要使用外部例程（DLL函数过程）的代码之前预定义该函数过程。即按DLL中的定义原样声明，且仅需要声明。同时加上external后缀引入，与export引出相对应。根据exports 的三种索引语法，也有三种确定例程的方式（以函数声明为例）：
function 函数名（参数表）：返回值；external ’DLL文件名’；
function 函数名（参数表）：返回值；external ’DLL文件名’ index 索引号；
function 函数名（参数表）：返回值；external ’DLL文件名’ name 新名称；
如果不确定例程名称，可以用索引方式引入。如果按原名引入会发生冲突，则可以用“新名称”引入。
进行声明后DLL函数的使用就和一般函数相同了。静态调用方式简单，但在启动调用程序时即调入DLL作为备用过程。如果此DLL文件不存在，那么启动时即会提示错误并立刻终止程序，不管定义是否使用。
快速查看DLL例程定义可以使用Borland附带的工具tdump.exe（在Delphi或BCB的bin目录下），示例如下：
Tdump cwindowssystemuser32.dll user32.txt
然后打开user32.txt文件，找到Exports from USER32.dll行，之下的部分就是DLL例程定义了，比如：
RV A Ord. Hint Name
-------- ---- ---- ----
00001371 1 0000 ActivateKeyboardLayout
00005C20 2 0001 AdjustWindowRect
0000161B 3 0002 AdjustWindowRectEx
Name列就是例程的名称，Ord就是该例程索引号。注意，该工具是不能得到例程的参数表的。如果参数错误，调用DLL例程会引起堆栈错误而导致调用程序崩溃。
调用代码
建立一个普通工程，在Main窗体上放置一个TShellTreeView控件（Samples页），再放置一个按钮，添加代码如下：
function DeleteDir(DirName: Pchar): boolean;stdcall;external 'FileOperate.dll';
procedure TForm1.Button1Click(Sender TObject);
begin
if DirectoryExists(ShellTreeView.Path) then
if Application.MessageBox(Pchar('确定删除目录'+QuotedStr(ShellTreeView.Path)+'吗？'), 'Information',MB_YESNO) = IDYes then
if DeleteDir(PChar(ShellTreeView.Path)) then
showmessage('删除成功');
end;
该范例调用的就是前面建立的DLL。
注意，声明时要包括stdcall后缀，这样才能保证调用Delphi开发的DLL的例程中类似PChar这样的参数值传递正确。大家有兴趣可以试验一下，不加入stdcall或者safecall后缀执行上面代码，将不能保证成功传递字符串参数给DLL函数。
调试方法
在Delphi主菜单Run项目中选择Parameters，打开“Run Parameters”对话框。在Host Application中填入一个宿主程序（该程序调用了将要调试的DLL），还可以在Parameters中输入参数。保存内容，然后就可以在DLL工程中设置断点、跟踪单步执行了。
Run该DLL工程，然后将运行宿主程序。执行会调用DLL的操作，然后就能跟踪进入该DLL的代码，接下来的调试操作和普通程序是一样的。
因为操作系统或其他软件影响的原因，可能会出现进行了上述步骤仍然无法正常跟踪中断DLL代码的情况。这时可以试试在菜单Project Options 对话框的 Linker 页面里将 EXE and DLL Options 中的Include TD32 debug info及include remote debug symbols两个选项选中。
假如还是不能中断 -_____- 那只好另外建立一个引用执行代码单元的应用程序，写代码调用例程调试完成后再编译DLL了（其实该方法有时候蛮方便的，但有时候亦非常麻烦）。
引入文件
DLL比较复杂时，可以为它的声明专门创建一个引入单元，这会使该DLL变得更加容易维护和查看。引入单元的格式如下：
unit MyDllImport; {Import unit for MyDll.dll }
interface
procedure MyDllProc;
…
implementation
procedure MyDllProc;external 'MyDll' index 1;
…
end.
这样以后想要使用MyDll中的例程时，只要简单的在程序模块中的uses子句中加上MyDllImport即可。其实这仅仅是种方便开发的技巧，大家打开Windows等引入windows API 的单元，可以看到类似的做法。
动态（显式）调用DLL
前面讲述静态调用DLL时提到，DLL会在启动调用程序时即被调入。所以这样的做法只能起到公用DLL以及减小运行文件大小的作用，而且DLL装载出错会立刻导致整个启动过程终止，哪怕该DLL在运行中只起到微不足道的作用。
使用动态调用DLL的方式，仅在调用外部例程时才将DLL装载内存（引用记数为0时自动将该DLL从内存中清除），从而节约了内存空间。而且可以判断装载是否正确以避免调用程序崩溃的情况，最多损失该例程功能而已。
动态调用虽然有上述优点，但是对于频繁使用的例程，因DLL的调入和释放会有额外的性能损耗，所以这样的例程则适合使用静态引入。
调用范例
DLL动态调用的原理是首先声明一个函数/过程类型并创建一个指针变量。为了保证该
指针与外部例程指针一致以确保赋值正确，函数/过程的声明必须和外部例程的原始声明兼容（兼容的意思是1、参数名称可以不一样；2、参数/返回值类型至少保持可以相互赋值，比如原始类型声明为Word，新的声明可以为Integer，假如传递的实参总是在Word的范围内，就不会出错）。
接下来通过windows API函数LoadLibrary引入指定的库文件，LoadLibrary的参数是DLL文件名，返回一个THandle。如果该步骤成功，再通过另一个API函数GetProcAddress 获得例程的入口地址，参数分别为LoadLibrary的指针和例程名，最终返回例程的入口指针。将该指针赋值给我们预先定义好的函数/过程指针，然后就可以使用这个函数/过程了。记住最后还要使用API函数FreeLibrary来减少DLL引用记数，以保证DLL使用结束后可以清除出内存。这三个API函数的Delphi声明如下：
Function LoadLibrary(LibFileName:PChar):THandle;
Function GetProcAddress(Module:THandle;ProcName:PChar):TfarProc;
Procedure FreeLibrary(LibModule:THandle);
将前面静态调用DLL例程的代码更改为动态调用，如下所示：
type
TDllProc = function (PathName : Pchar):boolean;stdcall;
var
LibHandle: THandle;
DelPath : TDllProc;
begin
LibHandle := LoadLibrary(PChar('FileOperate.dll'));
if LibHandle >= 32 then
begin
try
DelPath := GetProcAddress(LibHandle,PChar('DeleteDir'));
if DirectoryExists(ShellTreeView.Path) then
if Application.MessageBox(Pchar('确定删除目录'+QuotedStr(ShellTreeView.Path)+'吗？'), 'Information',MB_YESNO) = IDYes then
if DelPath(PChar(ShellTreeView.Path)) then
showmessage('删除成功');
finally
FreeLibrary(LibHandle);
end;
end;
end;
16位DLL的动态调入
下面将演示一个16位DLL例程调用的例子，该例程是windows9x中的一个隐藏API 函数。代码混合了静态、动态调用两种方式，除了进一步熟悉外，还可以看到调用16位DLL 的解决方法。先解释一下问题所在：
我要实现的功能是获得win9x的“系统资源”。在winNT/2000下是没有“系统资源”这个概念的，因为winNT/2000中堆栈和句柄不再象win9X那样被限制在６４Ｋ大小。为了取该值，可以使用win9x的user.dll中一个隐藏的API函数GetFreeSystemResources。
该DLL例程必须动态引入。如果静态声明的话，在win2000里执行就会立即出错。这个兼容性不解决是不行的。所以必须先判断系统版本，如果是win9x再动态加载。检查操作系统版本的代码是：
var
OSversion : _OSVERSIONINFOA;
FWinVerIs9x: Boolean;
begin
OSversion.dwOSVersionInfoSize := sizeof(_OSVERSIONINFOA);
GetVersionEx(OSversion);
FWinVerIs9x := OSversion.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS;
End;
以上直接调用API函数，已在Windows单元中被声明。
function LoadLibrary16(LibraryName: PChar): THandle; stdcall; external kernel32 index 35;
procedure FreeLibrary16(HInstance: THandle); stdcall; external kernel32 index 36;
function GetProcAddress16(Hinstance: THandle; ProcName: PChar): Pointer; stdcall; external kernel32 index 37;
function TWinResMonitor.GetFreeSystemResources(SysResource: Word): Word;
type
TGetFreeSysRes = function (value : integer):integer;stdcall;
TQtThunk = procedure();cdecl;
var
ProcHandle : THandle;
GetFreeSysRes : TGetFreeSysRes;
ProcThunkH : THandle;
QtThunk : TQtThunk;
ThunkTrash: array[0..$20] of Word;
begin
Result := 0;
ThunkTrash[0] := ProcHandle;
if FWinVerIs9x then
begin
ProcHandle := LoadLibrary16('user.exe');
if ProcHandle >= 32 then
begin
GetFreeSysRes:= GetProcAddress16(ProcHandle,Pchar('GetFreeSystemResources'));
if assigned(GetFreeSysRes) then
begin
ProcThunkH := LoadLibrary(Pchar('kernel32.dll'));
if ProcThunkH >= 32 then
begin
QtThunk := GetProcAddress(ProcThunkH,Pchar('QT_Thunk'));
if assigned(QtThunk) then
asm
push SysResource //push arguments
mov edx, GetFreeSysRes //load 16-bit procedure pointer
call QtThunk //call thunk
mov Result, ax //save the result
end;
end;
FreeLibrary(ProcThunkH);
end;
end;
FreeLibrary16(ProcHandle);
end
else Result := 100;
end;
首先，LoadLibrary16等三个API是静态声明的（也可以动态声明，我这么做是为了减少代码）。由于LoadLibrary无法正常调入16位的例程（微软啊！），所以改用 LoadLibrary16、FreeLibrary16、GetProcAddress16，它们与LoadLibrary、FreeLibrary、GetProcAddress的意义、用法、参数都一致，唯一不同的是必须用它们才能正确加载16位的例程。
在定义部分声明了函数指针TGetFreeSysRes 和TQtThunk。Stdcall、cdecl参数定义堆栈的行为，必须根据原函数定义，不能更改。
假如类似一般的例程调用方式，跟踪到这一步：if assigned(GetFreeSysRes)then begin GetFreeSysRes已经正确加载并且有了函数地址，却无法正常使用GetFreeSysRes(int)!!!
所以这里动态加载（理由也是在win2k下无法执行）了一个看似多余的过程QT_Thunk。
对于一个32位的外部例程，是不需要QT_Thunk的，但是，对于一个16位的例程，就必须使用如上汇编代码（不清楚的朋友请参考Delphi语法资料）：
asm
push SysResource
mov edx, GetFreeSysRes
call QtThunk
mov Result, ax
end;
它的作用是将压入参数压入堆栈，找到GetFreeSysRes的地址，用QtThunk来转换16位地址到32位，最后才能正确的执行并返回值！
以上16位DLL的部分在小仓系列中曾经提到过
Delphi开发DLL常见问题
字符串参数
前面曾提到过，为了保证DLL参数/返回值传递的正确性，尤其是为C++等其他语言开发的宿主程序使用时，应尽量使用指针或基本类型，因为其他语言与Delphi的变量存储分配方法可能是不一样的。C++中字符才是基本类型，串则是字符型的线形链表。所以最好将string强制转换为Pchar。
如果DLL和宿主程序都用Delphi开发，且使用string（还有动态数组，它们的数据结构类似）作为导出例程的参数/返回值，那么添加ShareMem为工程文件uses语句的第一个引用单元。ShareMem是Borland共享的内存管理器Borlndmm.dll的接口单元。引用该单元的DLL的发布需要包括Borlndmm.dll，否则就得避免使用string。
初始化COM库
如果在DLL中使用了TADOConnection之类的COM组件，或者ActiveX控件，调用时会提示“标记没有引用存储”等错误，这是因为没有初始化COM。DLL中不会调用CoInitilizeEx，初始化COM库被认为是应用程序的责任，这是Borland的实现策略。
你需要做的是：
1、引用Activex单元，保证CoInitilizeEx函数被正确调用了
2、在单元级加入初始化和退出代码：
initialization
Coinitialize(nil);
finalization
CoUninitialize;
end.
3、在结束时记住将连接和数据集关闭，否则也会报地址错误。
在DLL中建立及显示窗体
凡是基于窗体的Delphi应用程序都自动包含了一个全局对象Application，这点大家是
很熟悉的。值得注意的是Delphi创建的DLL同样有一个独立的Application。所以若是在
DLL中创建的窗体要成为应用程序的模式窗体的话，就必须将该Application替换为应用程
序的，否则结果难以预料（该窗体创建后，对它的操作比如最小化将不会隶属于任何主窗体）。
在DLL中要避免使用ShowMessage而用MessageBox。
创建DLL中的模式窗体比较简单，把Application.Handle属性作为参数传递给DLL例
程，将该句柄赋与Dll的Application.Handle，然后再用Application创建窗体就可以了。
无模式窗体则要复杂一些，除了创建显示窗体例程，还必须有一个对应的释放窗体例程。
对于无模式窗体需要十分小心，创建和释放例程的调用都需在调用程序中得到控制。这有两
层意思：一要防止同一个窗体实例的多次创建；二由应用程序创建一个无模式窗体必须保证
由应用程序释放，否则假如DLL中有另一处代码先行释放，再调用释放例程将会失败。
下面是DLL窗体的代码：
unit uSampleForm;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls;
type
TSampleForm = class(TForm)
Panel: TPanel;
end;
procedure CreateAndShowModalForm(AppHandle : THandle;Caption : PChar);export;stdcall;
function CreateAndShowForm(AppHandle : THandle):LongInt;export;stdcall;
procedure CloseShowForm(AFormRef : LongInt);export;stdcall;
implementation
{$R *.dfm}
//模式窗体
procedure CreateAndShowModalForm(AppHandle : THandle;Caption : PChar);
var
Form : TSampleForm;
str : string;
begin
Application.Handle := AppHandle;
Form := TSampleForm.Create(Application);
try
str := Caption;
Form.Caption := str;
Form.ShowModal;
finally
Form.Free;
end;
end;
//非模式窗体
function CreateAndShowForm(AppHandle : THandle):LongInt;
var
Form : TSampleForm;
begin
Application.Handle := AppHandle;
Form := TSampleForm.Create(Application);
Result := LongInt(Form);
Form.Show;
end;
procedure CloseShowForm(AFormRef : LongInt);
begin
if AFormRef > 0 then
TSampleForm(AFormRef).Release;
end;
end.
DLL工程单元的引出声明：
exports
CloseShowForm,
CreateAndShowForm,
CreateAndShowModalForm;
应用程序调用声明：
procedure CreateAndShowModalForm(Handle : THandle;Caption : PChar);stdcall;external
'FileOperate.dll';
function CreateAndShowForm(AppHandle : THandle):LongInt;stdcall;external 'FileOperate.dll';
procedure CloseShowForm(AFormRef : LongInt);stdcall;external 'FileOperate.dll';
除了普通窗体外，怎么在DLL中创建TMDIChildForm呢？其实与创建普通窗体类似，不过这次需要传递调用程序的Application.MainForm作为参数：
function ShowForm(mainForm:TForm):integer;stdcall
var
Form1: TForm1;
ptr:PLongInt;
begin
ptr:=@(Application.MainForm);//先把DLL的MainForm句柄保存起来，也无须释放，只不过是替换一下
ptr^:=LongInt(mainForm);//用调用程序的mainForm替换DLL的MainForm
Form1:=TForm1.Create(mainForm);//用参数建立
end;
代码中用了一个临时指针的原因在Application.MainForm是只读属性。MDI窗体的FormStyle不用设为fmMDIChild。
引出DLL中的对象
从DLL窗体的例子中可以发现，将句柄做为参数传递给DLL，DLL能指向这个句柄的实例。同样的道理，从DLL中引出对象，基本思路是通过函数返回DLL中对象的指针，将该指针赋值到宿主程序的变量，使该变量指向内存中某对象的地址。对该变量的操作即对DLL中的对象的操作。
本文不再详解代码，仅说明需要注意的几点规则：
1、应用程序只能访问对象中的虚拟方法，所以要引用的对象方法必须声明为虚方法；
2、 DLL和应用程序中都需要相同的对象及方法定义，且方法定义顺序必须一致；
3、 DLL中的对象无法继承；
4、对象实例只能在DLL中创建。
声明虚方法的目的不是为了重载，而是为了将该方法加入虚拟方法表中。对象的方法与普通例程是不同的，这样做才能让应用程序得到方法的指针。
DLL毕竟是结构化编程时代的产物，基于函数级的代码共享，实现对象化已经力不从心。现在类似DLL功能，但对对象提供强大支持的新方式已经得到普遍应用，象接口（COM/DCOM/COM+）之类的技术。进程内的服务端程序从外表看就是一个dll文件，但它不通过外部例程引出应用，而是通过注册发布一系列接口来提供支持。它与DLL从使用上有两个较大区别：需要注册，通过创建接口对象调用服务。可以看出，DLL虽然通过一
些技巧也可以引出对象，但是使用不便，而且常常将对象化强制转为过程化的方式，这种情况下最好考虑新的实现方法。
1制作好DLL之后，就可以用VB调用它，实现VB调用C程序。VB程序要使用DLL中的函数，首先必须要有特殊的声明，用Declare声明语句在窗体级或模块级或全局模块的代码声明段进行声明，将动态链接库中的函数声明到VB中，供VB程序调用。 语句格式为：Declare Sub过程名Lib[Alias"别名]（[ByVal参数AS类型]），或为Declare Function函数名Lib[Alias"别名]（[ByVal参数AS类型]）AS类型在声明中首先用Declare 关键字表示声明DLL中的函数。在C语言中有的函数类型为VOID，它表示不具有返回值，则必须用关键字Sub将其声明成过程。有的函数具有返回值，则必须用关键字Function将其声明成函数，并且在声明语句的最后要用AS关键字指明函数返回值的类型。 例如上面的ADD.DLL在VB中就可以声明为： Declare Function ADD Lib“c:\ADD.dll”(ByVal X AS Integer,ByVal Y AS Integer,ByVal filein asstring）AS Integer 通过此声明语句将函数ADD声明到VB中，便可直接调用。 2、dll文件中的函数好像是C语言写的, //函数名:int__stdcall GetMacNo(int*MacNo) //功能：获取卡机的卡机号(单机时) //参数:MacNo[0]-被读出的卡机号 //返回值：0-成功, //2-PC接收超时， //3-应答错误 dll的文件名是COMM232.dll 函数的形参int*MacNo是指针吗? 在VB中应该怎么声明和调用该函数? VB里也可以定义指针吗? 问题补充：vb调用dll文件中的函数我是会的,但这儿的形参有一个星号才不知是怎么一回事, 我是这样声明的对吗? Public Declare Function GetMacNo Lib"COMM232.dll"(ByVal MacNo As Integer)As Integer 又应该怎么调用呢?要先定义一个指针的变量再传给*MacNo还是要怎么做? 都说了MacNo是被读出的卡机号，那么就是传址的了。 dim l as integer dim m as integer l=GetMacNo(m) if l=0then label1.caption="卡机号:"&m elseif l=2then msgbox"PC接收超时" elseif l=3then msgbox"应答错误" end if
DELPHI中如何调用API,可举例说明 第一部分Delphi知识1. 如果一个元件希望放到IDE的元件面板上，它必须从________类派生，如果一个元件能作为其它元件的容器，它必须从_____________类派生，如果一个元件在运行时可见，它必须从___________________类派生(A)TGraphicControl (B)TWinContr 1、rtl70.bpl是什么？有什么用？ 2、delphi的Package相对dll有什么优点？ 3、以下的记录(结构)变量在内存占多少字节？type a = packed record v1: Byte; v2: Word; v3: string[16]; v4: Double; v5: string; v6: TForm; end; 4、以下的写法是否正确？type a 1.您为什么选择软件开发这个行业？(30字左右简写)； 2.如果有您解决不了的软件问题您会采取什么样的解决措施； 3.a.请您写出Object Pascal所支持的数据类型；b.请您写出Shl、Shr、Xor、Not 的数学表示法; 4.请您写出VCL结构层次(以TObject开始,最少五层）；5 二.是非题（共20道）1.从主菜单上选择Project|Syntax Check 菜单选项，Delphi将编译从上次编译后有改动的任何单元，并报出遇到的错误。（）2.Delphi的VCL对象有些是指针，从堆栈中分配空间，有些则不是。（）3.粘贴时，如果作为容器的组件已被选择，
剪贴 一.选择题（共40道）1.用户开发程序时需要经常在窗体和编辑器窗口之间来回切换，可使用快捷键（）。A、F12和F11 B、F12和F13 C、F12和Ctrl+F12 D、F12和Alt+F12 E、F12和Shift+F12 2.某函数如下：Function check(n,k:Integer):Integer; Var m:Integer; Beg 编程语言：delphi7.0或Vc++6.0 时间：4小时内环境：可参考帮助文档，但不能上网查资料1、编程查找指定目录下所有EXE 文件，并将其全路径存入Result.txt中，要求用递归。2、采用SOCKET(可用SOCKET API或delphi Socket控件)实现点对点传输大文件，要求不能掉
分早绑定和晚绑定两种。 早绑定的代码如下： unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; //MB 函数的声明： function MB(hWnd: HWND; lpText, lpCaption: PChar; uType: UINT): Integer; stdcall; implementation {$R *.dfm} {调用外部 DLL 中的函数，譬如调用系统 user32.dll 中的 MessageBoxA} //function MB(hWnd: HWND; lpText, lpCaption: PChar; uType: UINT): Integer; // stdcall; external user32 name 'MessageBoxA'; {其中 user32 是 Delphi 定义的常量 'user32.dll'，可以直接写成：} //function MB(hWnd: HWND; lpText, lpCaption: PChar; uType: UINT): Integer; // stdcall; external 'user32.dll' name 'MessageBoxA'; {name 后面说明函数的真实名字} {external 子句说明单元载入时就加载函数，也就是早绑定；如果晚绑定需要用LoadLibrary} {stdcall 指令表示参数传递是从右到左（Pascal则反之），不通过CPU寄存器
易语言中调用DLL使用说明 基本说明 本文所描述的部分功能需易语言4.01或以上版本支持。 “在易语言中调用DLL”包含两方面的内容：调用Windows系统API函数；调用普通DLL函数。 下文用到的“调用API”或“调用DLL”等字眼，除非特别注明，一般都是指以上两方面之一或之和，视上下文而定。绝大多数情况下，无需明确区分调用的是系统API还是普通DLL。 目前易语言只支持以stdcall方式调用DLL中的导出函数。 Windows系统API一般都是以stdcall调用方式导出的，故在易语言中调用它们时通常不必考虑函数调用方式的问题。而普通DLL有可能导出“非stdcall调用方式”（比如cdecl）的函数，调用时需要特别注意。一般而言，考虑到通用性，DLL开发者都会选择导出以sdtcall方式调用的函数。（支持生成DLL的编程语言通常都支持导出stdcall调用方式的函数，具体实现请参考各编程语言手册。） 易语言编译生成的DLL，其导出函数全部为stdcall调用方式，所以在易语言中调用易语言生成的DLL不存在问题。 目前在易语言中调用DLL时只支持1字节对齐的结构（自定义数据类型） 如果DLL命令的某个参数或参数的某个成员是结构类型（自定义数据类型），则其对齐方式必须是1字节对齐。Windows系统API中所用到的结构都是1字节对齐的，故在调用API时不受此限制。但如果想用其它编程语言生成DLL供易语言调用且数据类型中包含了1或2字节数据长度的成员（如字符型或短整数），就需要考虑结构的1字节对齐。
在Delphi中，可以这样定义1字节对齐的结构（结构在Delphi中称为record）： 在其它编程语言或编译器中的定义方式请参考各自的编程手册。 目前易语言支持调用任意复杂的DLL命令 只要满足了前面的两个条件——调用方式为stdcall，参数结构为1字节对齐——易语言支持调用任意复杂的DLL命令：参数除了可以是基本数据类型或普通结构类型外，还可以是基本类型地址或基本类型数组，也可以是结构类型地址或结构类型数组，结构类型的成员中还可以包含任意数量和任意层次的其它结构、结构地址、结构数组，等等。 DLL命令调用表 要在易语言中调用Windows API或普通DLL中的导出函数，必须首先在易语言中对该函数进行声明，声明的方式就是颇具易语言特色的“填写‘DLL命令调用表’”。“DLL命令调用表”正确填写完毕之后，就可以象调用普通易语言子程序一样调用DLL命令了。 下面重点说明“DLL命令调用表”的填写。 在易语言中，选择菜单“插入→DLL命令”即可插入一个空白的“DLL命令调用表”。当然还有其它操作方式，请参考易语言相关操作手册。
用Delphi制作DLL的方法 一Dll的制作一般步骤 二参数传递 三DLL的初始化和退出清理[如果需要初始化和退出清理] 四全局变量的使用 五调用静态载入 六调用动态载入 七在DLL建立一个TForM 八在DLL中建立一个TMDIChildForM 九示例： 十Delphi制作的Dll与其他语言的混合编程中常遇问题： 十一相关资料 一Dll的制作一般分为以下几步： 1 在一个DLL工程里写一个过程或函数 2 写一个Exports关键字，在其下写过程的名称。不用写参数和调用后缀。 二参数传递 1 参数类型最好与window C++的参数类型一致。不要用DELPHI的数据类型。 2 最好有返回值[即使是一个过程]，来报出调用成功或失败，或状态。成功或失败的返回值最好为1[成功]或0[失败].一句话，与windows c++兼容。 3 用stdcall声明后缀。 4 最好大小写敏感。 5 无须用far调用后缀，那只是为了与windows 16位程序兼容。 三DLL的初始化和退出清理[如果需要初始化和退出清理] 1 DLLProc[SysUtils单元的一个Pointer]是DLL的入口。在此你可用你的函数替换了它的入口。但你的函数必须符合以下要求[其实就是一个回调函数]。如下： procedure DllEnterPoint(dwReason: DWORD);far;stdcall; dwReason参数有四种类型： DLL_PROCESS_ATTACH:进程进入时 DLL_PROCESS_DETACH进程退出时 DLL_THREAD_A TTACH 线程进入时 DLL_THREAD_DETACH 线程退出时 在初始化部分写: DLLProc := @DLLEnterPoint; DllEnterPoint(DLL_PROCESS_ATTACH); 2 如Form上有TdcomConnection组件,就Uses Activex,在初始化时写一句CoInitialize (nil); 3 在退出时一定保证DcomConnection.Connected := False,并且数据集已关闭。否则报地址错。 四全局变量的使用 在widnows 32位程序中，两个应用程序的地址空间是相互没有联系的。虽然DLL在内存中是一份，但变量是在各进程的地址空间中，因此你不能借助dll的全局变量来达到两个应用
delphi中dll综合运用的例子(动态加载插件) 2008年01月15日星期二 10:59 1,新建dll客户端模块 ---------------dll工程文件PlugIns.dll------------------------------- library PlugIns; { Important note about DLL memory management: ShareMem must be the first unit in your library's USES clause AND your project's (select Project-View Source) USES clause if your DLL exports any procedures or functions that pass strings as parameters or function results. This applies to all strings passed to and from your DLL--even those that are nested in records and classes. ShareMem is the interface unit to the BORLNDMM.DLL shared memory manager, which must be deployed along with your DLL. To avoid using BORLNDMM.DLL, pass string information using PChar or ShortString parameters. } uses SysUtils, Classes, PlugInFrm in 'PlugInFrm.pas' {FrmPlugIns}; {$R *.res} //输出接口函数 exports ShowDLLForm,GetCaption; begin end. -------------新建模块PlugInFrm.pas的窗体文件--------------- unit PlugInFrm; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TFrmPlugIns = class(TForm) Label1: TLabel; private { Private declarations }
delphi如何调用C#的dll delphi如何调用C#的dll 发表于2010-03-11 16:37:13 Idelphi如何调用C#的dll ?在你的环境变量Path中加入 C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin; C:\WINNT\https://www.doczj.com/doc/b516875078.html,\Framework\v1.1.4322 随便建立一个ClassLibrary 编译成DLL 文件切换到MS-DOS 命令行下面，运行：C:\>regasm out ClassLibrary1.DLL /regfile:ClassLibrary1.reg 上面的命令行是注册我们的.NET 组件，并且产生了一个备用的注册表文件。对应Windows 的注册COM 文件命令：regsvr32 c:\test.dll . 在.NET下面，注册.NET组件就需要上面的regasm命令了然后在MS-DOS 命令行下面，运行： C:\>tlbExp ClassLibrary1.dll /out:ClassLibrary1.tlb 上面的命令行表示将会产生一个.NET 组件的类型库 有了TLB 文件也就和正常的COM 组件一样了,运行Delphi 导入类型库文件TLB ........... 和正常的COM 调用一样发表于2010-03-11 17:32:21 2 以前用delphi 写的CS 程序今天客户要加几个模块上去，刚
好会点C# ,这后面模块就用C#写的编译成dll文件，在用delphi 调用C#写的dll文件时折腾好阵子就有了这些经 历写下来。一、打开vs2005 新建windows 应用程序项目命名为SFrm,删除应用程序自动生成的Program.cs (因为我们 是要生成dll 文件)在窗体类新建一接口(interface SHFRM) 让窗体类实现接口代码如下：using System;using System.Collections.Generic;using https://www.doczj.com/doc/b516875078.html,ponentModel;using System.Data;using System.Data.SqlClient;using System.Drawing;using System.Text;using System.Windows.Forms;namespace SFrm{public interface SHFRM // 此接口用在delphi 下调用必须用到{void ShchildFrm();}public partial class Form1 : Form,SHFRM{private BindingSource bindingSource1 = new BindingSource();private SqlDataAdapter dataAdapter = new SqlDataAdapter();public Form1(){InitializeComponent();}/// /// 显示窗口/// public void ShchildFrm(){Form1 frm = new Form1();frm.Show();}/// /// 按钮事件/// /// /// private void button1_Click(object sender, EventArgs e){dataGridView1.DataSource = bindingSource1;GetData("select * from Customers");}private void GetData(string selectCommand){try{String connectionString = "Data Source=.;initial catalog=Northwind;user id =sa;pwd=";dataAdapter = new SqlDataAdapter(selectCommand,
一、开始你的第一个DLL专案 1.File->Close all->File->New﹝DLL﹞ 代码: //自动产生Code如下 library Project2; //这有段废话 uses SysUtils, Classes; {$R*.RES} begin end. 2.加个Function进来： 代码: library Project2; uses SysUtils, Classes; Function MyMax(X,Y:integer):integer;stdcall; begin if X>Y then Result:=X else Result:=Y; end;
//切记：Library的名字大小写没关系，可是DLL-Func的大小写就有关系了。//在DLL-Func-Name写成MyMax与myMAX是不同的。如果写错了，立即 //的结果是你叫用到此DLL的AP根本开不起来。 //参数的大小写就没关系了。甚至不必同名。如原型中是(X,Y:integer)但引//用时写成(A,B:integer)，那是没关系的。 //切记：要再加个stdcall。书上讲，如果你是用Delphi写DLL，且希望不仅给//Delphi-AP也希望BCB/VC-AP等使用的话，那你最好加个Stdcall;的指示//参数型态：Delphi有很多种它自己的变量型态，这些当然不是DLL所喜欢的//，Windows/DLL的母语应该是C。所以如果要传进传出DLL的参数，我们 //尽可能照规矩来用。这两者写起来，后者会麻烦不少。如果你对C不熟 //的话，那也没关系。我们以后再讲。 {$R*.RES} begin end. 3.将这些可共享的Func送出DLL，让外界﹝就是你的Delphi-AP啦﹞使用：光如此，你的AP还不能用到这些，你还要加个Exports才行。 代码: {$R*.RES} exports MyMax; begin end. 二、进行测试：开个新application： 1.加个TButton 代码: ShowMessage(IntToStr(MyMax(30,50)));
1、使用Visual C++ 6.0编写和链接DLL 打开Visual C++ 6.0集成开发环境，新建一个Win32 Dynamic-Link Library类型的工程CDLL，在工程中新建一个C语言源文件cdll.c。源文件中的内容如下： __declspec(dllexport) int max(int x,int y) /* 比较两个整型变量大小的函数max */ { if (x>y) return x; else return y; } 输入完毕后按下F7键来编译和链接CDLL.dll，之后可以在存放该工程的文件夹的Debug子文件夹中找到一个名为CDLL的DLL文件，该文件即以上的C语言源程序生成的DLL。 2、使用Delphi 7编写调用该DLL的应用程序 打开Delphi 7集成开发环境，在默认生成的窗体Form1上拖放3个Edit 控件Edit1、Edit2、Edit3和1个Button控件Button1，并在Object Inspector中将3个Edit控件的Text属性都清空。然后在默认生成的Unit1.pas文件的implementation后输入： function max(x,y: Integer): Integer; stdcall external 'CDLL.DLL';
返回Form1，双击Button1控件，在生成的事件处理程序中输入： Edit3.Text:=IntToStr(max(StrToInt(Edit1.Text), StrToInt(Edit2.Text))); 输入完毕后，保存这个Project。最后，将CDLL.dll文件copy到保存该Project的文件夹中。 3、测试 在Delphi集成开发环境下，按下F9来运行刚刚编写的Project。在Edit1中输入2，Edit2中输入4，然后单击Button1，可以看到Edit3中会出现4，测试成功。 4、基础知识 4.1、回调函数 软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。其中回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。同步调用是三者当中最简单的，而回调又常常是异步调用的基础。 回调函数与普通函数的申明并无区别，但如果是不同的开发语言之间通过回调函数来传递与处理数据，则一定要注意在不同语言对回调函数的申明与实现时其函数调用约定必须保持一致。 4.2、函数调用约定 声明过程或函数时，可以指定调用约定（calling convention）,尤其在以接口形式提供给其它语言工具使用时，则必须指定过程或函数的调用方式。 Delphi指定调用约定可以使用的指示字包括register、pascal、cdecl、stdcall 以及safecall。C/C++调用约定有stdcall、cdecl、fastcall、thiscall、naked call 等。 决定了传递给例程的参数的顺序，还影响参数从栈中的解除、参数传递时对寄存器的使用以及处理错误和异常等。缺省的调用约定是register。 下表是调用约定的简要概括：
Delphi 中的dll 封装和调用对象方法 2011-01-28 22:18 动态链接库是一种特殊格式的二进制数据文件，后缀名为.dll。它可以在程序运行时调用，并不需要进行重新编译，又由于它是完全独立的一个功能模块，使得其重用性非常好。将dll载入内存后，dll中的功能接口可以被系统中任何正在运行的应用程序所使用。具有节省空间，升级容易和高重用性等优点。 很多delphi的教材资料上讲到dll，大多都是将用dll来封装一些函数或者过程。但有时我们想把某个问题当成一个对象来处理，使程序模块化、组件化，方便团队开发、维护和更新。这时我们就需要用到dll封装和调用对象的技术，然而delphi在封装对象方面有一定的技术难度，资料也比较少，使得很多程序员认为delphi的dll不支持对象封装。下面简单分享一下我学习dll对象封装和调用的一些心得，希望能对这方面有需求的程序员一些帮助。 首先让我们认识一点，调用dll的程序只能使用与dll中对象动态绑定的方法，理解这一点是实现Dll封装和使用对象的关键。理解了这一点，我们就会想怎样才能实现与dll中对象的动态绑定呢？Delphi的接口技术为我们提供了一个好的选择，我们可以通过接口类去动态的获取dll中的对象。下面我用一个简单的demo来说明如何实现。 我建立了这样一个工程组，如下图 按如下几步进行： 1、先定义一个接口单元IDemo，代码如下： unit IDemo;
interface type IMax = interface (IInterface) function Max(num1, num2 : Integer) : Integer; end; implementation end. 建立我们需要封装的对象单元UnitMax.pas，注意看TMax继承自哪些父类，代码如下： unit UnitMax; interface uses IDemo; type TMax = class(TInterfacedObject, IMax) function Max( num1, num2 : Integer ) : Integer; end; implementation function TMax.Max(num1: Integer; num2: Integer) : Integer; begin Result := 0; if num1 > num2 then Result := num1 else Result := num2; end; end. 3、再在dll单元，输入如下代码：
C#中如何调用Delphi写的Dll C#中如何调用Delphi写的Dll 在以前用Delphi开发的项目中，会经常用到TChart这个画图控件，它本身很强大，支持各类图，如点线图，柏拉图，柱状图等等，加上可以输出成BMP，JPEG，JPG，SVG，GIF等各种格式图片，很好用，当时也封装成比较独立的DLL 文件。这次开发.net程序正好派上用场。 几个关键技术点： 1 C#要以非托管方式调用DLL 2 C#把整理好的画图数据生成事先定义好格式的XML 文件，传给DLL 3 DLL解析XML文件，根据相应格式，要求，画图 4 DLL输出GIF文件(经过比较GIF图像失真率小，且文件大小最小) 5 C#装载GIF文件，传到前台展示 关键代码： C# 以下是引用片段： #region 定义调用Delphi写的画图DLL /// /// 定义调用Delphi写的画图DLL
/// private class DrawChartFromDll { //定义DLL文件名，此文件路径要加到系统Path中 private const string _fileDll = @"Chart.dll"; //调用非托管Dll，GetChartFromXMLByNet是ChartAccess.dll公开的函数名称 [DllImport(_fileDll, EntryPoint = "GetChartFromXMLByNet", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] //C#中的申明 public static extern int GetChartFromXMLByNet(int piChartType, string psXMLFileName, string psPriChartFileName, string psSecChartFileName, string psPriHotFileName, string psSecHotFileName); } #endregion public ChartResultData GetCharts(ChartData _ChartData, Hashtable _HotPriAdditionSeqNo, Hashtable _HotSecAdditionSeqNo) { //根据数据生成XML文件
用DeIPhi制作DLL的方法 一Dll的制作一般步骤 二参数传递 三DLL的初始化和退出清理［如果需要初始化和退出清理］ 四全局变量的使用 五调用静态载入 六调用动态载入 七在DLL建立一个TForM 八在DLL中建立一个TMDIChiIdForM 九示例： 十DeIPhi制作的Dll与其他语言的混合编程中常遇问题：十一相关资料一Dll的制作一般分为以下几步： 1在一个DLL工程里写一个过程或函数 2写一个EXPOrtS关键字，在其下写过程的名称。不用写参数和调用后缀。 二参数传递 1参数类型最好与Window C++的参数类型一致。不要用DELPHI的数据类型。 2最好有返回值［即使是一个过程］,来报出调用成功或失败，或状态。成功或失败的返回值最好为1［成功］或0［失败］?一句话，与Windows c++兼容。 3用Stdcall声明后缀。 4最好大小写敏感。 5无须用far调用后缀，那只是为了与Windows 16位程序兼容。 三DLL的初始化和退出清理［如果需要初始化和退出清理］ 1 DLLProc［SysUtils单元的一个Pointer］是DLL的入口。在此你可用你的函数替换了它的入 口。但你的函数必须符合以下要求［其实就是一个回调函数］。如下： PrOCedUre DllE nterPoi nt(dwReaso n: DWoRD);far;StdCaII; dwReason参数有四种类型： DLL_PROCESS_ATTACH:进程进入时 DLL_PROCESS_DETACH 进程退出时 DLL_THREAD_A TTACH 线程进入时 DLL_THREAD_DETACH 线程退出时 在初始化部分写： DLLPrOC := @DLLE nterPoi nt; DIIE nterPoi nt(DLL_PROCESS_ATTACH); 2 女口Form 上有TdCOmCOnnectiOn 组件,就USeS Activex,在初始化时写一句CoInitialize (nil); 3在退出时一定保证DcomConnection.Connected := False,并且数据集已关闭。否则报地址错。 四全局变量的使用 在Widnows 32位程序中，两个应用程序的地址空间是相互没有联系的。虽然DLL在内存中 是一份，但变量是在各进程的地址空间中，因此你不能借助dll的全局变量来达到两个应用 程序间的数据传递，除非你用内存映像文件。
delphi编写调用有窗体有返回值的dll的实现方法 本人使用的delphi是版，用delphi编写dll工程很简单，在新建。。中就有创建Dll的选项。在编写DLL工程时，需要注意的包括，工程单元有很大差异，一个关键字是program ，一个关键字是library。dll工程单元中还包括exports 子句，那些需要提供给其他主叫程序调用的过程，都需要包括在exports中（只是列出函数的名字，不需要参数表）。对于主叫方（调用dll的应用程序或者其他dll），则需要在调用之前进行外部声明，即external保留字指示的声明。 另外需要了解object pascal中有关调用协议的内容，在object pascal中对于过程或函数有以下五种调用协议： 指示字参数传递顺序参数清除者参数是否使用寄存器 register 自左向右被调例程是 pascal 自左向右被调例程否 cdecl 自右向左调用者否 stdcall 自右向左被调用例程否 safecall 自右向左被调用例程否 这里的指示字就是在声明函数或过程时附加在例程标题之后的保留字，默认为register，即是唯一使用CPU寄存器的参数传递方式，也是传递速度最快的方式； pascal: 调用协议仅用于向后兼容，即向旧的版本兼容； cdecl: 多用于C和C++语言编写的例程，也用于需要由调用者清除参数的例程； stdcall: 和safecall主要用于调用Windows API 函数；其中safecall还用于双重接口。 现在以一个实例来说明一个用delphi编写的程序如何调用包含form窗体dll的程序。 Dll工程： library Project2; { Important note about DLL memory management: ShareMem must be the first unit in your library's USES clause AND your project's (select Project-View Source) USES clause if your DLL exports any procedures or functions that pass strings as parameters or function results. This applies to all strings passed to and from your DLL--even those that are nested in records and classes. ShareMem is the interface unit to the shared memory manager, which must be deployed along with your DLL. To avoid using , pass string information using PChar or ShortString parameters. } uses SysUtils, Classes, Unit1 in '' {Form1}; {$R *.RES} exports Execute name 'Execute';{过程来自于Unit1} begin end. —————————————————————————————————————— unit Unit1; interface
Delphi环境中编写调用DLL的方法和技巧 提起DLL您一定不会陌生，在Windows中有着大量的以DLL为后缀的文件，它们是保证Windows正常运行和维护升级的重要保证。（举个例子，笔者的Win95 System目录下尽有500多个DLL文件。）其实，DLL是一种特殊的可执行文件。说它特殊主要是因为一般它都不能直接运行，需要宿主程序比如*.EXE程序或其他DLL的动态调用才能够使用。简单的说，在通常情况下DLL是经过编译的函数和过程的集合。 使用DLL技术主要有以下几个原因： 一、减小可执行文件大小。 DLL技术的产生有很大一部分原因是为了减小可执行文件的大小。当操作系统进入Windows时代后，其大小已经达到几十兆乃至几百兆。试想如果还是使用DOS时代的单执行文件体系的话一个可执行文件的大小可能将达到数十兆，这是大家都不能接受的。解决的方法就是采用动态链接技术将一个大的可执行文件分割成许多小的可执行程序。 二、实现资源共享。 这里指的资源共享包括很多方面，最多的是内存共享、代码共享等等。早期的程序员经常碰到这样的事情，在不同的编程任务中编写同样的代码。这种方法显然浪费了很多时间，为了解决这个问题人们编写了各种各样的库。但由于编程语言和环境的不同这些库一般都不能通用，而且用户在运行程序时还需要这些库才行，极不方便。DLL的出现就像制定了一个标准一样，使这些库有了统一的规范。这样一来，用不同编程语言的程序员可以方便的使用用别的编程语言编写的DLL。另外，DLL还有一个突出的特点就是在内存中只装载一次，这一点可以节省有限的内存，而且可以同时为多个进程服务。 三、便于维护和升级。
Delphi 类库(DLL)动态调用与静态调用示例讲解 在Delphi或者其它程序中我们经常需要调用别人写好的DLL类库,下面直接上示例代码演示如何进行动态和静态的调用方法 { **********************************************************} { } { DLL动态调用与静态调用的例子} { 编译环境Delphi XE } { 转载或编译请不要修改此文件} { ******************************************************* ***} { ******************************************************* ***} { Designed by Jason 2013-08-30 } { ******************************************************* ***} program LoadDll; {$APPTYPE CONSOLE} uses SysUtils, windows; type TGetCPUID = function(CPUID: PAnsiChar): integer; stdcall; //注1 function GetCPUID(CPUID: PAnsiChar): integer; stdcall;external 'CPUID_Util.dll'; var dllHandle: THandle; GetId: TGetCPUID; Id: Array [0 .. 255] of Ansichar; //注2：DELPHI XE中使用Unicode编码字符串这里使用ansichar begin try //注3：静态调用 WriteLn('先尝试静态调用'); GetCPUID(Id); WriteLn(Id); if (Trim(Id) <> '') then WriteLn('静态调用成功,回车尝试动态调用') else
Delphi深入DLL编程 引言 相信有些计算机知识的朋友都应该听说过“DLL”。尤其是那些使用过windows操作系统的人，都应该有过多次重装系统的“悲惨”经历——无论再怎样小心，没有驱动损坏，没有病毒侵扰，仍然在使用（安装）了一段时间软件后，发现windows系统越来越庞大，操作越来越慢，还不时的出现曾经能使用的软件无法使用的情况，导致最终不得不重装系统。这种情况常常是由于dll文件的大量安装和冲突造成的。这一方面说明DLL的不足，另一方面也说明DLL的重要地位，以至我们无法杜绝它的使用。 DLL（动态链接库，Dynamic Link Library）简单来说是一种可通过调用执行的已编译的代码模块。DLL是windows系统的早期产物。当时的主要目的是为了减少应用程序对内存的使用。只有当某个函数或过程需要被使用时，才从硬盘调用它进入内存，一旦没有程序再调用该DLL了，才将其从内存中清除。光说整个windows系统，就包括了成百上千个dll 文件，有些dll文件的功能是比较专业（比如网络、数据库驱动）甚至可以不安装的。假如这些功能全部要包括在一个应用程序（Application program）里，windows将是一个数百M 大小的exe文件。这个简单的例子很容易解释DLL的作用，而调用DLL带来的性能损失则变得可被忽略不计。 多个应用程序调用同一个DLL，在内存里只有一个代码副本。而不会象静态编译的程序那样每一个都必须全部的被装入。装载DLL时，它将被映射到进程的地址空间，同时使用DLL的动态链接并非将库代码拷贝，而仅仅记录函数的入口点和接口。 同时DLL还能带来的共享的好处。一家公司开发的不同软件可能需要一些公用的函数过程，这些函数过程可能是直接的使用一些内部开发的DLL；一些常用的功能则可以直接使用windows的标准DLL，我们常说的windows API就是包含在windows几个公用DLL文件里的函数过程；理论上（如果不牵涉作者的版权），知道一个DLL的声明及作用（函数定义的输入参数及返回值），我们完全可以在不清楚其实现（算法或编译方式）的情况下直接使用它。 假如一个DLL中函数过程的算法得到了更新，BUG得到了修正，整个dll文件会得到升级。一般来说为了保证向下兼容，调用声明与返回结果应该保持不变。但实际上，即使是同一家开发的DLL，随着功能的改善，也很难保证某个调用执行完全不变。在使用其他人开发的DLL时这种糟糕情况更加的严重。比如我在一个绘图程序里使用了某著名图形软件商旧版本的DLL包，我所有的调用都是根据他发布的旧版的声明来执行的。假设用户安装了该软件商的一个新软件，导致其中部分DLL被更新升级，假如这些DLL已经有过改动，直接后果将是我的软件不再稳定甚至无法运行！不要轻视这种情况，事实上它是很普遍的，比如windows在修正BUG和升级过程中，就不断改动它包含的那些DLL。往往新版DLL 不是简单的增加新的函数过程，而是更换甚至取消了原有的声明，这时候我们再也无法保证所有程序都运行正常。
Delphi下写DLL的文章 Delphi制作DLL 一Dll的制作一般步骤 二参数传递 三DLL的初始化和退出清理[如果需要初始化和退出清理] 四全局变量的使用 五调用静态载入 六调用动态载入 七在DLL建立一个TForM 八在DLL中建立一个TMDIChildForM 九示例： 十Delphi制作的Dll与其他语言的混合编程中常遇问题： 十一相关资料 一Dll的制作一般分为以下几步： 1 在一个DLL工程里写一个过程或函数 2 写一个Exports关键字，在其下写过程的名称。不用写参数和调用后缀。 二参数传递 1 参数类型最好与window C++的参数类型一致。不要用DELPHI的数据类型。 2 最好有返回值[即使是一个过程]，来报出调用成功或失败，或状态。成功或失败的返回值最好为1[成功]或0[失败]. 一句话，与windows c++兼容。 3 用stdcall声明后缀。 4 最好大小写敏感。 5 无须用far调用后缀，那只是为了与windows 16位程序兼容。 三DLL的初始化和退出清理[如果需要初始化和退出清理] 1 DLLProc[SysUtils单元的一个Pointer]是DLL的入口。在此你可用你的函数替换了它的入口。但你的函数必须符合以下要求[其实就是一个回调函数]。如下： procedure DllEnterPoint(dwReason: DWORD);far;stdcall; dwReason参数有四种类型： DLL_PROCESS_ATTACH:进程进入时
DLL_THREAD_ATTACH :线程进入时 DLL_THREAD_DETACH :线程退出时 在初始化部分写: DLLProc := @DLLEnterPoint; DllEnterPoint(DLL_PROCESS_ATTACH); 2 如Form上有TdcomConnection组件,就Uses Activex,在初始化时写一句CoInitialize (nil); 3 在退出时一定保证DcomConnection.Connected := False,并且数据集已关闭。否则报地址错。 四全局变量的使用 在widnows 32位程序中，两个应用程序的地址空间是相互没有联系的。虽然DLL在内存中是一份，但变量是在各进程的地址空间中，因此你不能借助dll的全局变量来达到两个应用程序间的数据传递，除非你用内存映像文件。 五调用静态载入 1 客户端函数声名: 1)大小写敏感。 2)与DLL中的声明一样。 如：showform(form:Tform);Far;external'yproject_dll.dll'; 3)调用时传过去的参数类型最好也与windows c++一样。 4)调用时DLL必须在windows搜索路径中，顺序是：当前目录；Path路径； windows;widows\system;windows\ssystem32; 六调用动态载入 1 建立一种过程类型（或者是一个Function）[如果你对过程类型的变量只是一个指针的本质清楚的话，你就知道是怎么回事了]。如： type mypointer=procedure(form:Tform);Far;external; //mypointer=function(form:Tform);Far;external; var Hinst:Thandle; showform:mypointer; begin Hinst:=loadlibrary('yproject_dll');//Load一个Dll,按文件名找。