转【C#调用DLL的几种方法,包括C#调用C\C++\C#DLL】

2020年05月30日 阅读数:43
这篇文章主要向大家介绍转【C#调用DLL的几种方法,包括C#调用C\C++\C#DLL】,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

C#中dll调用方法

 
1、      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 时,此问题可能会更频繁地出现。
2、      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。
 
3、      结论
使用DLL有不少优势,如:节省内存和减小交换操做;开发大型程序时能够把某些模块分配给程序员,程序员能够用任何一门他所熟悉的语言把该模块编译成DLL文件,这样能够提升代码的复用,大大减轻程序员的工做量。固然DLL也有一些不足,如在提要中说起的问题。因此,如何灵活地调用DLL应该是每位程序员所熟知的。
C# 语言有不少优势,愈来愈多的人开始使用它来编程。可是,C#还有一些不足,如对很多的底层操做是无能为力的,只能经过调用Win32 DLL 或C++等编写的DLL;另外,通常认为C#程序的保密性不够强,由于它容易被Reflector 反编译而获得部分源码,因此须要使用混合编程增强C#程序的保密性,而把DLL嵌入C#程序并实现动态调用的方法是比较理想的方法,由于能够把DLL文件先用某一算法进行加密甚至压缩后再做为资源文件添加到C#程序中,在程序运行时才用某一算法进行解压解密后才进行加载,因此即便用反编译软件,也只能获得一个资源文件,且这个资源文件是用一个复杂算法进行加密过的,不可能再次对资源文件中的内容进行反编译,从而大大增强了代码的保密性。