之前在百度上找的不全 这个是全的调试通过可用
一、 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 ”上面添加如下代码声明参数传递方式枚举：
///
/// 参数传递方式枚举 ,ByValue 表示值传递 ,ByRef 表示址传递
///
public enum ModePass
{
ByValue = 0x0001,
ByRef = 0x0002
}
3. 声明 LoadLibrary 、 GetProcAddress 、 FreeLibrary 及私有变量 hModule 和 farProc ：
///
/// 原型是 :HMODULE LoadLibrary(LPCTSTR lpFileName);
///
/// DLL 文件名
/// 函数库模块的句柄
[DllImport("kernel32.dll")]
static extern IntPtr LoadLibrary(string lpFileName);
///
/// 原型是 : FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName);
///
/// 包含需调用函数的函数库模块的句柄
/// 调用函数的名称
/// 函数指针
[DllImport("kernel32.dll")]
static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
///
/// 原型是 : BOOL FreeLibrary(HMODULE hModule);
///
/// 需释放的函数库模块的句柄
/// 是否已释放指定的 Dll
[DllImport("kernel32",EntryPoint="FreeLibrary",SetLastError=true)]
static extern bool FreeLibrary(IntPtr hModule);
///
/// Loadlibrary 返回的函数库模块的句柄
///
private IntPtr hModule=IntPtr.Zero;
///
/// GetProcAddress 返回的函数指针
///
private IntPtr farProc=IntPtr.Zero;
4. 添加 LoadDll 方法，并为了调用时方便，重载了这个方法：
///
/// 装载 Dll
///
/// DLL 文件名
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 方法，并为了调用时方便，也重载了这个方法，方法的具体代码及注释如下：
///
/// 获得函数指针
///
/// 调用函数的名称
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+" 这个函数的入口点 "));
}
///
/// 获得函数指针
///
/// 包含需调用函数的 DLL 文件名
/// 调用函数的名称
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 方法也进行了重载：
///
/// 卸载 Dll
///
public void UnLoadDll()
{
FreeLibrary(hModule);
hModule=IntPtr.Zero;
farProc=IntPtr.Zero;
}
Invoke 方法的第一个版本：
///
/// 调用所设定的函数
///
/// 实参
/// 实参类型
/// 实参传送方式
/// 返回类型
/// 返回所调用函数的 object
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 方法的第二个版本，它是调用了第一个版本的：
///
/// 调用所设定的函数
///
/// 函数指针
/// 实参
/// 实参类型
/// 实参传送方式
/// 返回类型
/// 返回所调用函数的 object
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 类实例：
///
/// 创建一个 dld 类对象
///
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# 程序中，在程序运行时才用某一算法进行解压解密后才进行加载，所以即使用反编译软件，也只能得到一个资源文件，且这个资源文件是用一个复杂算法进行加密过的，不可能再次对资源文件中的内容进行反编译，从而大大加强了代码的保密性。
2788
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
