C#调用DLL函数方法

快来打我* 2024-04-19 13:48 5阅读 0赞

# C\#调用C++编写的COM DLL #

在C\#调用C++编写的COM DLL封装库时会出现两个问题：

1．  数据类型转换问题

2．  指针或地址参数传送问题

首先是数据类型转换问题。因为C\#是.NET语言，利用的是.NET的基本数据类型，所以实际上是将C++的数据类型与.NET的基本数据类型进行对应。

例如C++的原有函数是：

int \_\_stdcall FunctionName(unsigned char param1, unsigned short param2)

其中的参数数据类型在C\#中，必须转为对应的数据类型。如：

\[DllImport(“ COM DLL path/file ”)\]

extern static int FunctionName(byte param1, ushort param2)

因为调用的是\_\_stdcall函数，所以使用了P/Invoke的调用方法。其中的方法FunctionName必须声明为静态外部函数，即加上 extern static声明头。我们可以看到，在调用的过程中，unsigned char变为了byte，unsigned short变为了ushort。变换后，参数的数据类型不变，只是声明方式必须改为.NET语言的规范。

我们可以通过下表来进行这种转换：

<table> 
 <thead> 
  <tr> 
   <td> 
    <div> 
     <strong>Win32 Types</strong> 
    </div> </td> 
   <td> 
    <div> 
     <strong>CLR Type</strong> 
    </div> </td> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      char, INT8, SBYTE, CHAR&nbsp; 
    </div> </td> 
   <td> 
    <div>
      System.SByte 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      short, short int, INT16, SHORT 
    </div> </td> 
   <td> 
    <div>
      System.Int16 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      int, long, long int, INT32, LONG32, BOOL&nbsp;, INT 
    </div> </td> 
   <td> 
    <div>
      System.Int32 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      __int64, INT64, LONGLONG 
    </div> </td> 
   <td> 
    <div>
      System.Int64 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      unsigned char, UINT8, UCHAR&nbsp;, BYTE 
    </div> </td> 
   <td> 
    <div>
      System.Byte 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      unsigned short, UINT16, USHORT, WORD, ATOM, WCHAR&nbsp;, __wchar_t 
    </div> </td> 
   <td> 
    <div>
      System.UInt16 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      unsigned, unsigned int, UINT32, ULONG32, DWORD32, ULONG, DWORD, UINT 
    </div> </td> 
   <td> 
    <div>
      System.UInt32 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      unsigned __int64, UINT64, DWORDLONG, ULONGLONG 
    </div> </td> 
   <td> 
    <div>
      System.UInt64 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      float, FLOAT 
    </div> </td> 
   <td> 
    <div>
      System.Single 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      double, long double, DOUBLE 
    </div> </td> 
   <td> 
    <div>
      System.Double 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

之后再将CLR的数据类型表示方式转换为C\#的表示方式。这样一来，函数的参数类型问题就可以解决了。

现在，我们再来考虑下一个问题，如果要调用的函数参数是指针或是地址变量，怎么办？

对于这种情况可以使用C\#提供的非安全代码来进行解决，但是，毕竟是非托管代码，垃圾资源处理不好的话对应用程序是很不利的。所以还是使用C\#提供的 ref以及out修饰字比较好。

同上面一样，我们也举一个例子：

int \_\_stdcall FunctionName(unsigned char &param1, unsigned char \*param2)

在C\#中对其进行调用的方法是：

\[DllImport(“ COM DLL path/file ”)\]

extern static int FunctionName(ref byte param1, ref byte param2)

看到这，可能有人会问，&是取地址，\*是传送指针，为何都只用ref就可以了呢？一种可能的解释是ref是一个具有重载特性的修饰符，会自动识别 是取地址还是传送指针。

在实际的情况中，我们利用参数传递地址更多还是用在传送数组首地址上。

如：byte\[\] param1 = new param1(6);

在这里我们声明了一个数组，现在要将其的首地址传送过去，只要将param1数组的第一个元素用ref修饰。具体如下：

\[DllImport(“ COM DLL path/file ”)\]

extern static int FunctionName(ref byte param1\[1\], ref byte param2)

**C\#调用DLL函数方法**

http://www.csharpwin.net/ddwstp/net/csharp/5964dr984.shtml

http://www.csharpwin.net/ddwstp/net/csharp/5970dr7788.shtml

首先，理解托管代码与非托管代码的区别：

1.托管代码所申请的资源统一由.Net Framework管理，你不用操心，非托管代码所申请的内存等资源则需要你手动去释放

2.非托管程序运行会很快,是二进制的,托管程序好写,但是速度就差的很多,资源会用的很多

3.“程序"一般都是在对操作系统进行直接或者间接的操作

"托管程序"是需要通过访问公共语言运行时（cls）才能访问操作系统的程序，而“非托管程序”不用通过访问公共语言运行时（cls）可以直接访问操作系 统的程序

4.vb.net，C\#等写的程序是托管程序，VC++可以写托管程序，如果用到了内存管理，则只能编译为非托管程序

VC++写托管的是要用.net的库，因为我们没有用.net，所以只用了非托管方式。

(一) C\#调用DLL中的非托管函数一般方法

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

\[DLLImport(“DLL文件”)\]

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

其中：

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

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

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

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

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

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

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

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

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

其它可选的 DllImportAttribute 属性：

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

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

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

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

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

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

举例：

New file，选择visual C\# Class。在文件中，创建一个public的类。把待测试的函数在这个类中作声明。

1.  public class ClassName      
2.  \{         
3.     \[DllImport("xxx.dll", EntryPoint = "xx")\]  
4.          public static extern int StartVideo(
5.  int nDevNum, int SwitchingChans, IntPtr Main, IntPtr hwndPreview);   
6.  \}

Xxx为待测试的dll名称，xx为dll中提供的方法函数。若要使用其它函数名，可以使用EntryPoint属性设置。

如何用DllImport调用DLL中的非托管函数，但是这个是全局的函数，假若DLL中的非托管函数有一个静态变量S，每次调用这个函数的时候，静态变 量S就自动加1。结果，当需要重新计数时，就不能得出想要的结果。所以，要注意啊，用DllImport调用DLL中的非托管函数是全局的、静态的函数。

以上介绍的就是C\#调用DLL函数方法（上），剩下的内容将在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.打开项目“Test”，打开类视图，右击“Tzb”，选择“添加”-->“类”，类名设置为“dld”，即dynamic loading dll 的每个单词的开头字母。

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

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

3. 在namespace test中，“public class dld”的上面，添加如下代码声明参数传递方式枚举：

1.  /// < summary>    
2.      /// 参数传递方式枚举,ByValue 表示值传递,ByRef 表示址传递   
3.      /// < /summary>    
4.      public enum ModePass   
5.      \{  
6.          ByValue = 0x0001,   
7.          ByRef = 0x0002   
8.  \}

4、在public class DLD中，添加如下代码：

1.  public class DLD  
2.      \{  
3.          \[DllImport("kernel32.dll")\]  
4.          public static extern IntPtr LoadLibrary(string lpFileName);  
5.   
6.          \[DllImport("kernel32.dll")\]  
7.          public static extern IntPtr GetProcAddress(
8.  IntPtr hModule, string lpProceName);  
9.   
10.    
11.  
12.         \[DllImport("kernel32", EntryPoint = "FreeLibrary", SetLastError = true)\]  
13.           public static extern bool FreeLibrary(IntPtr hModule);  
14.  
15.    
16.  
17.         /// < summary>    
18.         /// Loadlibrary 返回的函数库模块的句柄    
19.         /// < /summary>    
20.         private IntPtr hModule = IntPtr.Zero;  
21.   
22.         /// < summary>    
23.         /// GetProcAddress 返回的函数指针    
24.         /// < /summary>   
25.         private IntPtr farProc = IntPtr.Zero;  
26.  
27.         /// < summary>    
28.         /// 装载 Dll    
29.         /// < /summary>    
30.         /// < param name="lpFileName">DLL 文件名 < /param>   
31.         public void LoadDll(string lpFileName)  
32.         \{  
33.   
34.             hModule = LoadLibrary(lpFileName);  
35.  
36.             if (hModule == IntPtr.Zero)  
37.                 throw (new Exception(" 没有找到 :" + lpFileName + "."));  
38.         \}  
39.  
40.  
41.         /// < summary>   
42.         /// 获得函数指针    
43.         /// < /summary>   
44.         /// < param name="lpProcName"> 调用函数的名称 < /param>    
45.         public void LoadFun(string lpProcName)   
46.         \{ // 若函数库模块的句柄为空，则抛出异常   
47.             if (hModule == IntPtr.Zero)   
48.                 throw (new Exception(
49. " 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));   
50.             // 取得函数指针   
51.             farProc = GetProcAddress(hModule, lpProcName);  
52.             // 若函数指针，则抛出异常    
53.             if (farProc == IntPtr.Zero)   
54.                 throw (new Exception(
55. " 没有找到 :" + lpProcName + " 这个函数的入口点 "));   
56.         \}  
57.  
58.    
59.  
60.         /// < summary>    
61.         /// 卸载 Dll    
62.         /// < /summary>    
63.         public void UnLoadDll()   
64.         \{  
65.            FreeLibrary(hModule);   
66.             hModule = IntPtr.Zero;   
67.             farProc = IntPtr.Zero;  
68.         \}  
69.  
70.    
71.         /// < summary>    
72.         /// 调用所设定的函数   
73.         /// < /summary>   
74.         /// < param name="ObjArray\_Parameter"> 实参 < /param>   
75.         /// < param name="TypeArray\_ParameterType"> 实参类型 < /param>   
76.         /// < param name="ModePassArray\_Parameter"> 实参传送方式 < /param>   
77.         /// < param name="Type\_Return"> 返回类型 < /param>    
78.         /// < returns> 返回所调用函数的 object< /returns>   
79.         public object Invoke(
80. object\[\] ObjArray\_Parameter, Type\[\] TypeArray\_ParameterType,
81.  ModePass\[\] ModePassArray\_Parameter, Type Type\_Return)  
82.         \{  
83.             // 下面 3 个 if 是进行安全检查 , 若不能通过 , 则抛出异常   
84.             if (hModule == IntPtr.Zero)  
85.                 throw (new Exception(
86. " 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));  
87.  
88.             if (farProc == IntPtr.Zero)  
89.                 throw (new Exception(" 函数指针为空 , 请确保已进行 LoadFun 操作 !"));  
90.        if (ObjArray\_Parameter.Length != ModePassArray\_Parameter.Length)  
91.                 throw (new Exception(" 参数个数及其传递方式的个数不匹配 ."));  
92.  
93.             // 下面是创建 MyAssemblyName 对象并设置其 Name 属性  
94.             AssemblyName MyAssemblyName = new AssemblyName();  
95.             MyAssemblyName.Name = "InvokeFun";  
96.  
97.             // 生成单模块配件   
98.             AssemblyBuilder MyAssemblyBuilder = 
99. AppDomain.CurrentDomain.DefineDynamicAssembly(
100. MyAssemblyName, AssemblyBuilderAccess.Run);  
101.             ModuleBuilder MyModuleBuilder = MyAssemblyBuilder.DefineDynamicModule(
102. "InvokeDll");  
103.   
104.             // 定义要调用的方法 , 方法名为“ MyFun ”，
105. //返回类型是“ Type\_Return ”参数类型是“ TypeArray\_ParameterType ”   
106.             MethodBuilder MyMethodBuilder = MyModuleBuilder.DefineGlobalMethod(
107. "MyFun", MethodAttributes.Public | MethodAttributes.Static,
108. Type\_Return, TypeArray\_ParameterType);  
109.   
110.             // 获取一个 ILGenerator ，用于发送所需的 IL   
111.             ILGenerator IL = MyMethodBuilder.GetILGenerator();  
112.             int i;  
113.             for (i = 0; i <  ObjArray\_Parameter.Length; i++)   
114.             \{ // 用循环将参数依次压入堆栈   
115.                 switch (ModePassArray\_Parameter\[i\])   
116.                 \{      
117.                     case ModePass.ByValue:  
118.                         IL.Emit(OpCodes.Ldarg, i);   
119.                         break;  
120.                     case ModePass.ByRef:  
121.                         IL.Emit(OpCodes.Ldarga, i);  
122.                         break;  
123.                     default:  
124.                         throw (new Exception(
125. " 第 " + (i + 1).ToString() + " 个参数没有给定正确的传递方式 ."));  
126. break;
127.                 \}  
128.             \}  
129.  
130.             if (IntPtr.Size == 4)   
131.             \{ // 判断处理器类型   
132.                 IL.Emit(OpCodes.Ldc\_I4, farProc.ToInt32());  
133.             \}  
134.             else if (IntPtr.Size == 8)   
135.             \{  
136.                 IL.Emit(OpCodes.Ldc\_I8, farProc.ToInt64());   
137.             \}   
138.             else  
139.             \{       
140.                 throw new PlatformNotSupportedException();    
141.             \}  
142.  
143.             IL.EmitCalli(OpCodes.Calli, CallingConvention.StdCall, 
144. Type\_Return, TypeArray\_ParameterType);  
145.      
146.             IL.Emit(OpCodes.Ret); // 返回值   
147.             MyModuleBuilder.CreateGlobalFunctions();  
148.  
149.             // 取得方法信息    
150.             MethodInfo MyMethodInfo = MyModuleBuilder.GetMethod("MyFun");
151. // 调用方法，并返回其值 
152.             return MyMethodInfo.Invoke(null, ObjArray\_Parameter);    
153.         \}  
154.     \}

2) dld类的使用：

1．打开项目“Test”，向“Form1”窗体中添加一个按钮，和一个TestBox，Name改为txRet。视图中双击按钮，在 “button1\_Click”方法体上面添加代码，创建一个dld类实例，并进行测试。具体如下：

1.  private void button1\_Click(object sender, EventArgs e)  
2.          \{  
3.              int ret = 0;   
4.              dld myDLD = new dld();    
5.              myDLD.LoadDll("xxx.dll");   
6.              myDLD.LoadFun("InitSDK");  
7.              object\[\] Parameters = new object\[\] \{ \}; // 实参为0     
8.              Type\[\] ParameterTypes = new Type\[\] \{ \}; // 实参类型为int   
9.              ModePass\[\] themode = new ModePass\[\] \{ \}; // 传送方式为值传  
10.  
11.             Type Type\_Return = typeof(int); // 返回类型为int  
12.             ret = (int)myDLD.Invoke(
13. Parameters, ParameterTypes, themode, Type\_Return);  
14.  
15.             txRet.Text = ret.ToString();  
16.             if (ret != 1)  
17.             \{  
18.                 MessageBox.Show("InitSDK failed !");   
19.             \}  
20.  
21.             if (ret == 1)  
22.             \{   
23.                 MessageBox.Show("InitSDK Sucessed !");  
24.             \}   
25.         \}

其中，xxx为要测试的dll名称，InitSDK为dll中的要测试的函数。

至此，C\#调用DLL函数方法就介绍完了，希望对大家有所帮助。

转载于:https://my.oschina.net/alphajay/blog/6697