C#程序实现动态调用DLL的研究

C#

程序实现动态调用

DLL

的研究


摘
要：
在《
csdn
开发高手》
2004
年第
03
期中的《化功大法——将
DLL
嵌入
EXE
》一文，介绍了如何把一个动态链接库作为一个资源嵌入到可执行文件，在可执行文件运行时，自动从资源中释放出来，通过静态加载延迟实现ＤＬＬ函数的动态加载，程序退出后实现临时文件的自动删除，从而为解决“
DLL Hell
”提供了一种解决方案。这是一个很好的设计思想，而且该作者也用
C++
实现了，在
Internet
上也有相似的
VB
程序，但在某一技术论坛上提起这种设计方法时，有网友提出：“这种方法好是好，但就是启动速度太慢”。这是因为程序启动时实现
DLL
释放，然后再加载释放出来的
DLL
，这个过程会耗费一定的时间。鉴于此问题，经过思索，提出另一个设计方案：
DLL
作为资源文件嵌入程序，但不需进行
DLL
释放及其重新加载。本文就是对该设计方案的原理分析及使用
C#
编程来实现该设计方案。

关键词：
动态调用
DLL
，嵌入
DLL
，
C#

正
文：

一、


DLL

与应用程序


动态链接库（也称为
DLL
，即为“
Dynamic Link Library
”的缩写）是
Microsoft Windows
最重要的组成要素之一，打开
Windows
系统文件夹，你会发现文件夹中有很多
DLL
文件，
Windows
就是将一些主要的系统功能以
DLL
模块的形式实现。

动态链接库是不能直接执行的，也不能接收消息，它只是一个独立的文件，其中包含能被程序或其它
DLL
调用来完成一定操作的函数
(
方法。注：
C#
中一般称为“方法”
)
，但这些函数不是执行程序本身的一部分，而是根据进程的需要按需载入，此时才能发挥作用。

DLL
只有在应用程序需要时才被系统加载到进程的虚拟空间中，成为调用进程的一部分，此时该
DLL
也只能被该进程的线程访问，它的句柄可以被调用进程所使用，而调用进程的句柄也可以被该
DLL
所使用。在内存中，一个
DLL
只有一个实例，且它的编制与具体的编程语言和编译器都没有关系，所以可以通过
DLL
来实现混合语言编程。
DLL
函数中的代码所创建的任何对象（包括变量）都归调用它的线程或进程所有。

下面列出了当程序使用
DLL
时提供的一些优点：
[1]

1)


使用较少的资源


当多个程序使用同一个函数库时，
DLL
可以减少在磁盘和物理内存中加载的代码的重复量。这不仅可以大大影响在前台运行的程序，而且可以大大影响其他在
Windows
操作系统上运行的程序。

2)


推广模块式体系结构


DLL
有助于促进模块式程序的开发。这可以帮助您开发要求提供多个语言版本的大型程序或要求具有模块式体系结构的程序。模块式程序的一个示例是具有多个可以在运行时动态加载的模块的计帐程序。

3)


简化部署和安装


当
DLL
中的函数需要更新或修复时，部署和安装
DLL
不要求重新建立程序与该
DLL
的链接。此外，如果多个程序使用同一个
DLL
，那么多个程序都将从该更新或修复中获益。当您使用定期更新或修复的第三方
DLL
时，此问题可能会更频繁地出现。

二、


DLL

的调用


每种编程语言调用
DLL
的方法都不尽相同，在此只对用
C#
调用
DLL
的方法进行介绍。首先
,
您需要了解什么是托管
,
什么是非托管。一般可以认为：非托管代码主要是基于
win 32
平台开发的
DLL
，
activeX
的组件，托管代码是基于
.net
平台开发的。如果您想深入了解托管与非托管的关系与区别，及它们的运行机制，请您自行查找资料，本文件在此不作讨论。

(一)


调用

DLL

中的非托管函数一般方法


首先

，应该在
C#
语言源程序中声明外部方法，其基本形式是：

[DLLImport(“DLL
文件
”)]

修饰符
extern
返回变量类型
方法名称
（参数列表）

其中

：

DLL
文件：包含定义外部方法的库文件。

修饰符：
访问修饰符，除了
abstract
以外在声明方法时可以使用的修饰符。

返回变量类型：在
DLL
文件中你需调用方法的返回变量类型。

方法名称：在
DLL
文件中你需调用方法的名称。

参数列表：在
DLL
文件中你需调用方法的列表。

注意

：需要在程序声明中使用
System.Runtime.InteropServices
命名空间。

DllImport
只能放置在方法声明上。

DLL
文件必须位于程序当前目录或系统定义的查询路径中（即：系统环境变量中
Path
所设置的路径）。

返回变量类型、方法名称、参数列表一定要与
DLL
文件中的定义相一致。

若要使用其它函数名，可以使用
EntryPoint
属性设置，如：

[DllImport("user32.dll", EntryPoint="MessageBoxA")]

static extern int MsgBox(int hWnd, string msg, string caption, int type);

其它可选的
DllImportAttribute
属性：

CharSet
指示用在入口点中的字符集，如：
CharSet=CharSet.Ansi
；

SetLastError
指示方法是否保留
Win32"
上一错误
"
，如：
SetLastError=true
；

ExactSpelling
指示
EntryPoint
是否必须与指示的入口点的拼写完全匹配，如：
ExactSpelling=false
；

PreserveSig
指示方法的签名应当被保留还是被转换，
如：
PreserveSig=true
；

CallingConvention
指示入口点的调用约定，
如：
CallingConvention=CallingConvention.Winapi
；

此外，关于“数据封送处理”及“封送数字和逻辑标量”请参阅其它一些文章
[2]
。

C#

例子：


1.

启动
VS.NET
，新建一个项目，项目名称为“
Tzb
”，模板为“
Windows
应用程序”。

2.

在“工具箱”的“
Windows
窗体”项中双击“
Button
”项，向“
Form1
”窗体中添加一个按钮。

3.

改变按钮的属性：
Name
为
“B1”
，
Text
为
“
用
DllImport
调用
DLL
弹出提示框
”
，并将按钮
B1
调整到适当大小，移到适当位置。

4.

在类视图中双击“
Form1
”，打开“
Form1
．
cs
”代码视图，在“
namespace Tzb
”上面输入“
using System.Runtime.InteropServices;
”，以导入该命名空间。

5.

在“
Form1
．
cs
［设计］”视图中双击按钮
B1
，在“
B1_Click
”方法上面使用关键字
static
和
extern
声明方法“
MsgBox
”，将
DllImport
属性附加到该方法，这里我们要使用的是“
user32
．
dll
”中的“
MessageBoxA
”函数，具体代码如下：

[DllImport("user32.dll", EntryPoint="MessageBoxA")] static extern int MsgBox(int hWnd, string msg, string caption, int type);

然后在“
B1_Click
”方法体内添加如下代码，以调用方法“
MsgBox
”：

MsgBox(0," 这就是用 DllImport 调用 DLL 弹出的提示框哦！ "," 挑战杯 ",0x30);

6.

按“
F5”

运行该程序，并点击按钮
B1
，便弹出如下提示框：



(二)


动态装载、调用

DLL

中的非托管函数


在上面已经说明了如何用
DllImport
调用
DLL
中的非托管函数，但是这个是全局的函数，假若
DLL
中的非托管函数有一个静态变量
S
，每次调用这个函数的时候，静态变量
S
就自动加
1
。结果，当需要重新计数时，就不能得出想要的结果。下面将用例子说明：

1.


DLL

的创建


1)


启动
Visual C++ 6.0
；

2)


新建一
个“
Win32 Dynamic-Link Library
”工程，工程名称为“
Count
”；

3)


在“
Dll kind
”选择界面中选择“
A simple dll project
”；

4)


打开
Count.cpp
，添加如下代码：

// 导出函数，使用“ _stdcall ” 标准调用 extern "C" _declspec(dllexport)int _stdcall count(int init);

int _stdcall count(int init) {//count 函数，使用参数 init 初始化静态的整形变量 S ，并使 S 自加 1 后返回该值 static int S=init; S++; return S; }

5)


按“
F7”

进行编译，得到
Count.dll
（在工程目录下的
Debug
文件夹中）。

2.


用DllImport
调用DLL
中的count
函数


1)


打开项目“
Tzb
”，向“
Form1”

窗体中添加一个按钮。

2)


改变按钮的属性：
Name
为
“
B2
”，
Text
为
“用
DllImport
调用
DLL
中
count
函数”，并将按钮
B1
调整到适当大小，移到适当位置。

3)


打开“
Form1
．
cs
”代码视图，使用关键字
static
和
extern
声明方法“
count
”，并使其具有来自
Count.dll
的导出函数
count
的实现，代码如下：

[DllImport("Count.dll")] static extern int count(int init);

4)


在“
Form1
．
cs
［设计］”视图中双击按钮
B2
，在“
B2_Click
”方法体内添加如下代码：

MessageBox.Show(" 用 DllImport 调用 DLL 中的 count 函数， /n 传入的实参为 0 ，得到的结果是： "+count(0).ToString()," 挑战杯 "); MessageBox.Show(" 用 DllImport 调用 DLL 中的 count 函数， /n 传入的实参为 10 ，得到的结果是： "+count(10).ToString()+"/n 结果可不是想要的 11 哦！！！ "," 挑战杯 "); MessageBox.Show(" 所得结果表明： /n 用 DllImport 调用 DLL 中的非托管 /n 函数是全局的、静态的函数！！！ "," 挑战杯 ");

5)


把
Count.dll
复制到项目“
Tzb
”的
bin/Debug
文件夹中，按“
F5”

运行该程序，并点击按钮
B2
，便弹出如下三个提示框：







第
1
个提示框显示的是调用“
count(0)
”的结果，第
2
个提示框显示的是调用“
count(10)
”的结果，由所得结果可以证明“用
DllImport
调用
DLL
中的非托管函数是全局的、静态的函数”。所以，有时候并不能达到我们目的，因此我们需要使用下面所介绍的方法：
C#
动态调用
DLL
中的函数。

3.


C#

动态调用

DLL

中的函数


因为
C#
中使用
DllImport
是不能像动态
load/unload assembly
那样，所以只能借助
API
函数了。在
kernel32.dll
中，与动态库调用有关的函数包括
[3]
：

①
LoadLibrary
（或
MFC
的
AfxLoadLibrary
），装载动态库。

②
GetProcAddress
，获取要引入的函数，将符号名或标识号转换为
DLL
内部地址。

③
FreeLibrary
（或
MFC
的
AfxFreeLibrary
），释放动态链接库。

它们的原型分别是：

HMODULE LoadLibrary(LPCTSTR lpFileName);

FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName);

BOOL FreeLibrary(HMODULE hModule);

现在，我们可以用
IntPtr hModule=LoadLibrary(“Count.dll”);
来获得
Dll
的句柄
,
用
IntPtr farProc=GetProcAddress(hModule,”
_count@4”

);
来获得函数的入口地址。

但是，知道函数的入口地址后，怎样调用这个函数呢？因为在
C#
中是没有函数指针的，没有像
C++
那样的函数指针调用方式来调用函数，所以我们得借助其它方法。经过研究，发现我们可以通过结合使用
System.Reflection.Emit
及
System.Reflection.Assembly
里的类和函数达到我们的目的。为了以后使用方便及实现代码的复用，我们可以编写一个类。

1)


dld

类的编写：


1.

打开项目“
Tzb
”，打开类视图，右击“
Tzb
”，选择“添加”
-->
“类”，类名设置为“

dld

”，即
dynamic loading dll

的每个单词的开头字母。

2.

添加所需的命名空间及声明参数传递方式枚举：

using System.Runtime.InteropServices; // 用 DllImport 需用此 命名空间 using System.Reflection; // 使用 Assembly 类需用此 命名空间 using System.Reflection.Emit; // 使用 ILGenerator 需用此 命名空间

在“
public class dld

”上面添加如下代码声明参数传递方式枚举：

/// <summary> /// 参数传递方式枚举 ,ByValue 表示值传递 ,ByRef 表示址传递 /// </summary> public enum ModePass { ByValue = 0x0001, ByRef = 0x0002 }

3.

声明

LoadLibrary
、
GetProcAddress
、
FreeLibrary
及私有变量
hModule
和
farProc
：

/// <summary> /// 原型是 :HMODULE LoadLibrary(LPCTSTR lpFileName); /// </summary> /// <param name="lpFileName">DLL 文件名 </param> /// <returns> 函数库模块的句柄 </returns> [DllImport("kernel32.dll")] static extern IntPtr LoadLibrary(string lpFileName); /// <summary> /// 原型是 : FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName); /// </summary> /// <param name="hModule"> 包含需调用函数的函数库模块的句柄 </param> /// <param name="lpProcName"> 调用函数的名称 </param> /// <returns> 函数指针 </returns> [DllImport("kernel32.dll")] static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName); /// <summary> /// 原型是 : BOOL FreeLibrary(HMODULE hModule); /// </summary> /// <param name="hModule"> 需释放的函数库模块的句柄 </param> /// <returns> 是否已释放指定的 Dll</returns> [DllImport("kernel32",EntryPoint="FreeLibrary",SetLastError=true)] static extern bool FreeLibrary(IntPtr hModule); /// <summary> /// Loadlibrary 返回的函数库模块的句柄 /// </summary> private IntPtr hModule=IntPtr.Zero; /// <summary> /// GetProcAddress 返回的函数指针 /// </summary> private IntPtr farProc=IntPtr.Zero;

4.

添加
LoadDll
方法，并为了调用时方便，重载了这个方法：

/// <summary> /// 装载 Dll /// </summary> /// <param name="lpFileName">DLL 文件名 </param> public void LoadDll(string lpFileName) { hModule=LoadLibrary(lpFileName); if(hModule==IntPtr.Zero) throw(new Exception(" 没有找到 :"+lpFileName+"." )); }

若已有已装载
Dll
的句柄，可以使用
LoadDll
方法的第二个版本：

public void LoadDll(IntPtr HMODULE) { if(HMODULE==IntPtr.Zero) throw(new Exception(" 所传入的函数库模块的句柄 HMODULE 为空 ." )); hModule=HMODULE; }

5.

添加
LoadFun
方法，并为了调用时方便，也重载了这个方法，方法的具体代码及注释如下：

/// <summary> /// 获得函数指针 /// </summary> /// <param name="lpProcName"> 调用函数的名称 </param> public void LoadFun(string lpProcName) { // 若函数库模块的句柄为空，则抛出异常 if(hModule==IntPtr.Zero) throw(new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !")); // 取得函数指针 farProc = GetProcAddress(hModule,lpProcName); // 若函数指针，则抛出异常 if(farProc==IntPtr.Zero) throw(new Exception(" 没有找到 :"+lpProcName+" 这个函数的入口点 ")); } /// <summary> /// 获得函数指针 /// </summary> /// <param name="lpFileName"> 包含需调用函数的 DLL 文件名 </param> /// <param name="lpProcName"> 调用函数的名称 </param> public void LoadFun(string lpFileName,string lpProcName) { // 取得函数库模块的句柄 hModule=LoadLibrary(lpFileName); // 若函数库模块的句柄为空，则抛出异常 if(hModule==IntPtr.Zero) throw(new Exception(" 没有找到 :"+lpFileName+"." )); // 取得函数指针 farProc = GetProcAddress(hModule,lpProcName); // 若函数指针，则抛出异常 if(farProc==IntPtr.Zero) throw(new Exception(" 没有找到 :"+lpProcName+" 这个函数的入口点 ")); }

6.

添加
UnLoadDll
及
Invoke
方法，
Invoke
方法也进行了重载：

/// <summary> /// 卸载 Dll /// </summary> public void UnLoadDll() { FreeLibrary(hModule); hModule=IntPtr.Zero; farProc=IntPtr.Zero; }

Invoke
方法的第一个版本：

/// <summary> /// 调用所设定的函数 /// </summary> /// <param name="ObjArray_Parameter"> 实参 </param> /// <param name="TypeArray_ParameterType"> 实参类型 </param> /// <param name="ModePassArray_Parameter"> 实参传送方式 </param> /// <param name="Type_Return"> 返回类型 </param> /// <returns> 返回所调用函数的 object</returns> public object Invoke(object[] ObjArray_Parameter,Type[] TypeArray_ParameterType,ModePass[] ModePassArray_Parameter,Type Type_Return) { // 下面 3 个 if 是进行安全检查 , 若不能通过 , 则抛出异常 if(hModule==IntPtr.Zero) throw(new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !")); if(farProc==IntPtr.Zero) throw(new Exception(" 函数指针为空 , 请确保已进行 LoadFun 操作 !" ) ); if(ObjArray_Parameter.Length!=ModePassArray_Parameter.Length) throw(new Exception(" 参数个数及其传递方式的个数不匹配 ." ) ); // 下面是创建 MyAssemblyName 对象并设置其 Name 属性 AssemblyName MyAssemblyName = new AssemblyName(); MyAssemblyName.Name = "InvokeFun"; // 生成单模块配件 AssemblyBuilder MyAssemblyBuilder =AppDomain.CurrentDomain.DefineDynamicAssembly(MyAssemblyName,AssemblyBuilderAccess.Run); ModuleBuilder MyModuleBuilder =MyAssemblyBuilder.DefineDynamicModule("InvokeDll"); // 定义要调用的方法 , 方法名为“ MyFun ”，返回类型是“ Type_Return ”参数类型是“ TypeArray_ParameterType ” MethodBuilder MyMethodBuilder =MyModuleBuilder.DefineGlobalMethod("MyFun",MethodAttributes.Public| MethodAttributes.Static,Type_Return,TypeArray_ParameterType); // 获取一个 ILGenerator ，用于发送所需的 IL ILGenerator IL = MyMethodBuilder.GetILGenerator(); int i; for (i = 0; i < ObjArray_Parameter.Length; i++) {// 用循环将参数依次压入堆栈 switch (ModePassArray_Parameter[i]) { case ModePass.ByValue: IL.Emit(OpCodes.Ldarg, i); break; case ModePass.ByRef: IL.Emit(OpCodes.Ldarga, i); break; default: throw(new Exception(" 第 " +(i+1).ToString() + " 个参数没有给定正确的传递方式 ." ) ); } } if (IntPtr.Size == 4) {// 判断处理器类型 IL.Emit(OpCodes.Ldc_I4, farProc.ToInt32()); } else if (IntPtr.Size == 8) { IL.Emit(OpCodes.Ldc_I8, farProc.ToInt64()); } else { throw new PlatformNotSupportedException(); } IL.EmitCalli(OpCodes.Calli,CallingConvention.StdCall,Type_Return,TypeArray_ParameterType); IL.Emit(OpCodes.Ret); // 返回值 MyModuleBuilder.CreateGlobalFunctions(); // 取得方法信息 MethodInfo MyMethodInfo = MyModuleBuilder.GetMethod("MyFun"); return MyMethodInfo.Invoke(null, ObjArray_Parameter);// 调用方法，并返回其值 }

Invoke
方法的第二个版本，它是调用了第一个版本的：

/// <summary> /// 调用所设定的函数 /// </summary> /// <param name="IntPtr_Function"> 函数指针 </param> /// <param name="ObjArray_Parameter"> 实参 </param> /// <param name="TypeArray_ParameterType"> 实参类型 </param> /// <param name="ModePassArray_Parameter"> 实参传送方式 </param> /// <param name="Type_Return"> 返回类型 </param> /// <returns> 返回所调用函数的 object</returns> public object Invoke(IntPtr IntPtr_Function,object[] ObjArray_Parameter,Type[] TypeArray_ParameterType,ModePass[] ModePassArray_Parameter,Type Type_Return) { // 下面 2 个 if 是进行安全检查 , 若不能通过 , 则抛出异常 if(hModule==IntPtr.Zero) throw(new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !")); if(IntPtr_Function==IntPtr.Zero) throw(new Exception(" 函数指针 IntPtr_Function 为空 !" ) ); farProc=IntPtr_Function; return Invoke(ObjArray_Parameter,TypeArray_ParameterType,ModePassArray_Parameter,Type_Return); }

2)


dld

类的使用：


1．

打开项目“
Tzb

”，向“
Form1”

窗体中添加

三个按钮。

Name
和
Text
属性分别为
“
B3”

、“用
LoadLibrary
方法装载
Count.dll
”，“
B4”

、“调用
count
方法”，“
B5”

、“卸载
Count.dll
”，并调整到适当的大小及位置
。

2．

在“
Form1

．
cs

［设计］”视图中双击按钮
B3

，在“
B3_Click

”方法体上面添加代码，创建一个
dld

类实例：

/// <summary> /// 创建一个 dld 类对象 /// </summary> private dld myfun=new dld();

3．

在“
B3_Click

”方法体内添加如下代码：

myfun.LoadDll("Count.dll"); // 加载 "Count.dll" myfun.LoadFun("_count@4"); // 调入函数 count, "_count@4" 是它的入口，可通过 Depends 查看

4．

“
Form1

．
cs

［设计］”视图中双击按钮
B4

，在“
B4_Click

”方法体内添加如下代码：

object[] Parameters = new object[]{(int)0}; // 实参为 0 Type[] ParameterTypes = new Type[]{typeof(int)}; // 实参类型为 int ModePass[] themode=new ModePass[]{ModePass.ByValue}; // 传送方式为值传 Type Type_Return = typeof(int); // 返回类型为 int // 弹出提示框，显示调用 myfun.Invoke 方法的结果，即调用 count 函数 MessageBox.Show(" 这是您装载该 Dll 后第 "+myfun.Invoke(Parameters,ParameterTypes,themode,Type_Return).ToString() +" 次点击此按钮。 "," 挑战杯 ");

5．

“
Form1

．
cs

［设计］”视图中双击按钮
B5

，在“
B5_Click

”方法体内添加如下代码：

myfun.UnLoadDll();

6．

按“
F5

”运行该程序，并先点击按钮
B3

以

加载“Count.dll
”
，接着点击按钮
B4

三次以调用
3

次“

count(0)
”，
先后弹出的提示框如下：







这三个提示框所得出的结果说明了静态变量
S

经初始化后，再传入实参“
0
”
也不会改变其值为“
0
”
。

7．

点击按钮
B5

以卸载“
Count.dll

”，再点击按钮
B3

进行装载“
Count.dll

”，再点击按钮
B4

查看调用了“
count(0)

”的结果：



从弹出的提示框所显示的结果可以看到又开始重新计数了，也就是实现了DLL
的动态装载与卸载了。

(三)



调用托管


DLL


一般方法


C#

调用托管
DLL

是很简单的，只要在“解决方案资源管理器”中的需要调用
DLL

的项目下用鼠标右击“引用”，并选择“添加引用”，然后选择已列出的
DLL

或通过浏览来选择
DLL

文件，最后需要用
using

导入相关的命名空间。

(四)



动态调用托管


DLL


C#

动态调用托管
DLL

也需要借助

System.Reflection.Assembly
里的类和方法，主要使用了
Assembly.LoadFrom
。现在，用例子说明：

首先，启动
VS.NET
，新建一个
Visual C#
项目，使用的模板为“类库”，名称为“
CsCount
”，并在类“
Class1”

中

添加静态整型变量
S
及方法
count
：

// 由于 static 不能修饰方法体内的变量，所以需放在这里，且初始化值为 int.MinValue static int S=int.MinValue; public int count(int init) {// 判断 S 是否等于 int.MinValue ，是的话把 init 赋值给 S if(S==int.MinValue) S=init; S++; //S 自增 1 return S; // 返回 S }

然后，打开项目“
Tzb
”，向“
Form1”

窗体中添加

一个按钮，
Name
属性为“
B6”

，
Text
属性为“用
Assembly
类来动态调用托管
DLL
”，调整到适当大小和位置，双击按钮
B6
，转入代码视图，先导入命名空间：
using System.Reflection;
接着添加
Invoke
方法和
B6_Click
方法代码：

private object Invoke(string lpFileName,string Namespace,string ClassName,string lpProcName,object[] ObjArray_Parameter) { Try { // 载入程序集 Assembly MyAssembly=Assembly.LoadFrom(lpFileName); Type[] type=MyAssembly.GetTypes(); foreach(Type t in type) {// 查找要调用的命名空间及类 if(t.Namespace==Namespace&&t.Name==ClassName) {// 查找要调用的方法并进行调用 MethodInfo m=t.GetMethod(lpProcName); if(m!=null) { object o=Activator.CreateInstance(t); return m.Invoke(o,ObjArray_Parameter); } else MessageBox.Show(" 装载出错 !"); } } }//try catch(System.NullReferenceException e) { MessageBox.Show(e.Message); }//catch return (object)0; }// Invoke

“
B6_Click
”方法体内代码如下：

// 显示 count(0) 返回的值 MessageBox.Show(" 这是您第 "+Invoke("CsCount.dll","CsCount","Class1","count",new object[]{(int)0}).ToString()+" 次点击此按钮。 "," 挑战杯 ");

最后，把项目“
CsCount
”的
bin/Debug
文件夹中的
CsCount.dll
复制到项目“
Tzb
”的
bin/Debug
文件夹中，按“
F5”

运行该程序，并点击按钮
B6
三次，将会弹出
3
个提示框，内容分别是“这是您第
1
次点击此按钮。”、“这是您第
2
次点击此按钮。”、“这是您第
3
次点击此按钮。”，由此知道了静态变量
S
在这里的作用。

(


五


) C#


程序


嵌入

DLL

的调用


DLL
文件作为资源嵌入在
C#

程序

中，我们只要读取该资源文件并以“
byte[]
”返回，然后就用“Assembly Load(byte[]);
”得到
DLL
中的
程序集，最后就可以像上面的
Invoke
方法那样对
DLL
中的方法进行调用。当然不用上面方法也可以，如用接口实现动态调用，但
DLL
中必须有该接口的定义并且程序
中也要有该接口的定义；也可用反射发送实现动态调用
[4]
。现在我只对
像上面的
Invoke
方法那样对
DLL
中的方法进行调用进行讨论，为了以后使用方便及实现代码的复用，我们可以结合上一个编写一个类。

1)


ldfs

类的编写：


在项目“
Tzb
”中新建一个名为
ldfs
的类，意为“
load dll from resource
”，请注意，在这个类中“
resource
”不只是嵌入在
EXE
程序中的资源，它也可以是硬盘上任意一个
DLL
文件，这是因为
ldfs
的类中的方法
LoadDll
有些特别，就是先从程序的内嵌的资源中查找需加载的
DLL
，如果找不到，就查找硬盘上的。

首先导入所需的命名空间：

using System.IO; // 对文件的读写需要用到此命名空间 using System.Reflection; // 使用 Assembly 类需用此命名空间 using System.Reflection.Emit; // 使用 ILGenerator 需用此命名空间

声明一静态变量
MyAssembly
：

// 记录要导入的程序集 static Assembly MyAssembly;

添加
LoadDll
方法：

private byte[] LoadDll(string lpFileName) { Assembly NowAssembly = Assembly.GetEntryAssembly(); Stream fs=null; try {// 尝试读取资源中的 DLL fs = NowAssembly.GetManifestResourceStream(NowAssembly.GetName().Name+"."+lpFileName); } finally {// 如果资源没有所需的 DLL ，就查看硬盘上有没有，有的话就读取 if (fs==null&&!File.Exists(lpFileName)) throw(new Exception(" 找不到文件 :"+lpFileName)); else if(fs==null&&File.Exists(lpFileName)) { FileStream Fs = new FileStream(lpFileName, FileMode.Open); fs=(Stream)Fs; } } byte[] buffer = new byte[(int) fs.Length]; fs.Read(buffer, 0, buffer.Length); fs.Close(); return buffer; // 以 byte[] 返回读到的 DLL }

添加
UnLoadDll
方法来卸载
DLL
：

public void UnLoadDll() {// 使 MyAssembly 指空 MyAssembly=null; }

添加
Invoke
方法来进行对
DLL
中方法的调用，其原理大体上和“
Form1
．
cs
”中的方法
Invoke
相同，不过这里用的是
“
Assembly.Load
”，而且用了
静态变量
MyAssembly
来保存已加载的
DLL
，如果已加载的话就不再加载，如果还没加载或者已加载的不同现在要加载的
DLL
就进行加载，其代码如下所示：

public object Invoke(string lpFileName,string Namespace,string ClassName,string lpProcName,object[] ObjArray_Parameter) { try {// 判断 MyAssembly 是否为空或 MyAssembly 的命名空间不等于要调用方法的命名空间，如果条件为真，就用 Assembly.Load 加载所需 DLL 作为程序集 if(MyAssembly==null||MyAssembly.GetName().Name!=Namespace) MyAssembly=Assembly.Load(LoadDll(lpFileName)); Type[] type=MyAssembly.GetTypes(); foreach(Type t in type) { if(t.Namespace==Namespace&&t.Name==ClassName) { MethodInfo m=t.GetMethod(lpProcName); if(m!=null) {// 调用并返回 object o=Activator.CreateInstance(t); return m.Invoke(o,ObjArray_Parameter); } else System.Windows.Forms.MessageBox.Show(" 装载出错 !"); } } } catch(System.NullReferenceException e) { System.Windows.Forms.MessageBox.Show(e.Message); } return (object)0; }

2)


ldfs

类的使用：


1．
把
CsCount.dll
作为“嵌入的资源”添加到项目“
Tzb
”中。

2．
向“
Form1
”窗体中添加两个按钮，
Name
和
Text
属性分别为“
B7
”、“
ldfs.Invoke
调用
count
”；“
B8
”、“
UnLoadDll
”，并将它们调整到适当大小和位置。

3．
打开“
Form1
．
cs
”代码视图，添加一个
ldfs
实例：

// 添加一个 ldfs 实例 tmp private ldfs tmp=new ldfs();

4．
在“
Form1
．
cs
［设计］”视图中双击按钮
B7
，在“
B1_Click
”方法体内添加如下代码：

// 调用 count(0), 并使用期提示框显示其返回值 MessageBox.Show(" 这是您第 "+tmp.Invoke("CsCount.dll","CsCount","Class1","count",new object[]{(int)0}).ToString()+" 次点击此按钮。 "," 挑战杯 ");

5．
在“
Form1
．
cs
［设计］”视图中双击按钮
B7
，在“
B1_Click
”方法体内添加如下代码：

// 卸载 DLL tmp.UnLoadDll();

6．
“
F5
”运行该程序，并先点击按钮
B7
三次，接着点击按钮
B8
，最后再点击按钮
B7
，此时发现又开始重新计数了，情况和“
dld
类的使用”类似，
也就是也实现了DLL
的动态装载与卸载了
。

说明：以上所用到的所有源代码详见附件
1:Form1.cs
、附件
2:dld.cs
、附件
3:ldfs.cs
、附件
4:Count.cpp
、附件
5:Class1.cs
。

三、


结


论


使用
DLL
有很多优点，如：节省内存和减少交换操作；开发大型程序时可以把某些模块分配给程序员，程序员可以用任何一门他所熟悉的语言把该模块编译成
DLL
文件，这样可以提高代码的复用，大大减轻程序员的工作量。当然
DLL
也有一些不足，如在提要中提及的问题。所以，如何灵活地调用
DLL
应该是每位程序员所熟知的。

C#
语言有很多优点，越来越多的人开始使用它来编程。但是，
C#
还有一些不足，如对不少的底层操作是无能为力的，只能通过调用
Win32 DLL
或
C++
等编写的
DLL
；另外，一般认为
C#
程序的保密性不够强，因为它容易被
Reflector
反编译而得到部分源码，所以需要使用混合编程加强
C#
程序的保密性，而把
DLL
嵌入
C#
程序并实现动态调用的方法是比较理想的方法，因为可以把
DLL
文件先用某一算法进行加密甚至压缩后再作为资源文件添加到
C#
程序中，在程序运行时才用某一算法进行解压解密后才进行加载，所以即使用反编译软件，也只能得到一个资源文件，且这个资源文件是用一个复杂算法进行加密过的，不可能再次对资源文件中的内容进行反编译，从而大大加强了代码的保密性。

参考文献：

[1]
引自：
《什么是
DLL?
》，网址：
http://support.microsoft.com/default.aspx?scid=kb;zh-cn;815065

[2]
《在
C#
中通过
P/Invoke
调用
Win32 DLL
》
Jason Clark
，

网址：
http://www.microsoft.com/china/msdn/library/langtool/vcsharp/ousNET.mspx

[3]
《深入分析
Windows
和
Linux
动态库应用异同》刘世栋

杨林，

网址：
http://tech.ccidnet.com/art/302/20050919/336005_1.html

[4]
《
C#
程序设计》
Jesse Liberty
著

刘基诚

译
,
中国电力出版社