C#时常需要调用C++DLL

忘是亡心i 2022-08-23 12:51 247阅读 0赞

# C\#调用C/C++的动态连接库 #

1，清楚C++与C\#类型对应关系，即调用关系：

![C调用C/C++动态链接库(.dll)详解 - CSharp - C][C_C_C_.dll_ - CSharp - C]

除此之外,

c++:HANDLE(void \*) ---- c\#:System.IntPtr

c++:WORD(unsigned short) ---- c\#:System.UInt16

c++:DWORD(unsigned long) ---- c\#:System.UInt32

c++:结构体 ---- c\#:public struct 结构体\{\};

c++:结构体 &变量名 ---- c\#:ref 结构体 变量名

c++:结构体 \*\*变量名 ---- c\#:out

c++:GUID ---- c\#:Guid

c++:UINT8 \* ---- c\#:ref byte

c++:char\*/void\*(指向一个字符串) ---- c\#:string

对于结构体中的指针数组，对应于C\#中的IntPtr\[\]类型，如:

int \* a\[\] -------------- IntPtr\[\]a

2，清楚在C\#中调用C/C++.dll文件的一般格式

using System.Runtime.InteropServices; //必须引用的命名空间

\[DllImport("user32.dll")\]  
public static extern ReturnType FunctionName(type arg1,type arg2,...);

//必须定义为类的静态外部的方法

3，\[DllImport(参数)\]设定

①“xx.dll” ：dll文件名字

②CharSet ：控制调用函数的名称版本及指示如何向方法封送 String 参数。如果 CharSet字段设置为 Unicode，则所有字符串参数在传递到非托管实现之前都转换成 Unicode 字符。这还导致向 DLL EntryPoint 的名称中追加字母“W”。如果此字段设置为 Ansi，则字符串将转换成ANSI 字符串，同时向 DLL EntryPoint 的名称中追加字母“A”。

EntryPoint 指示要调用的 DLL 入口点的名称或序号。如果你想使用自己定义的函数名字fucXX，则：”EntryPoint=fucXX”。

③ExactSpelling：指示是否应修改非托管 DLL 中的入口点的名称，以与 CharSet 字段中指定的 CharSet 值相对应。如果为 true，则当 DllImportAttribute.CharSet 字段设置为CharSet 的 Ansi 值时，向方法名称中追加字母 A，当 DllImportAttribute.CharSet 字段设置为 CharSet 的 Unicode 值时，向方法的名称中追加字母 W。此字段的默认值是 false。

④PreserveSig：指示托管方法签名不应转换成返回 HRESULT、并且可能有一个对应于返回值的附加 \[out, retval\] 参数的非托管签名。

⑤SetLastError：指示被调用方在从属性化方法返回之前将调用 Win32 API SetLastError。true 指示调用方将调用 SetLastError，默认为 false。

4，具体实例

C中API函数：

Unsigned long int Fuc (int a,void\* b);

C\#中定义：

\[DllImport("testall.dll", ExactSpelling = false)\]

public extern static UInt32 Fuc(int a, IntPtr b);//

C中结构体：

\#define M 5

typedef struct \_\_BITMAP\{

DWord pPixelArrayFormat;

Long lWidth;

Long lHeight;

Long lBuffer \[MPAF\_MAX\_PLANES\];

Byte\* pPointer\[MPAF\_MAX\_PLANES\];

\}BITMAP

C\#定义：

\[StructLayout(LayoutKind.Sequential)\] //此句在C\#中重新定义结构体时一定要加上

public struct BITMAP

\[MarshalAs(UnmanagedType.U4)\]

public UInt32 pPixelArrayFormat;

\[MarshalAs(UnmanagedType.I4)\]

public Int32 lWidth;

\[MarshalAs(UnmanagedType.I4)\]

public Int32 lHeight;

\[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)\]

public Int32\[\] lBuffer;

\[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)\]

public IntPtr\[\] pPointer;   //对于结构体中的指针数组，一般采用IntPtr数组

对于上面的这个结构体,如果在C/C++中出现了结构体指针,那么我们应该在C\#中使用IntPtr类型变量，然后使用如下方法将指针指向结构体。

定义结构体对象S，则在C\#中获取结构体指针的方法如下：

IntPtr intptr = Marshal.AllocHGlobal(Marshal.SizeOf(S));   
Marshal.StructureToPtr(S, intptr, false); //将指针intptr指向结构体

操作之后一定要释放内存——  
Marshal.FreeHGlobal(intptr);//释放分配的非托管内存。

反之也可以由指向结构体的指针变量获取结构体。Marshal.PtrToStructure();

//====================================================================================================//

在合作开发时，C\#时常需要调用C++DLL，当传递参数时时常遇到问题，尤其是传递和返回字符串是，现总结一下，分享给大家：

VC++中主要字符串类型为：LPSTR,LPCSTR, LPCTSTR, string, CString, LPCWSTR, LPWSTR等  
但转为C\#类型却不完全相同。

主要有如下几种转换：

将string转为IntPtr：IntPtr System.Runtime.InteropServices.Marshal.StringToCoTaskMemAuto(string)

将IntPtr转为string：string System.Runtime.InteropServices.MarshalPtrToStringAuto(IntPtr)

类型对照：

BSTR ---------  StringBuilder

LPCTSTR --------- StringBuilder

LPCWSTR ---------  IntPtr

handle---------IntPtr

hwnd-----------IntPtr

char \*----------string

int \* -----------ref int

int &-----------ref int

void \*----------IntPtr

unsigned char \*-----ref byte

Struct需要在C\#里重新定义一个Struct

CallBack回调函数需要封装在一个委托里，delegate static extern int FunCallBack(string str);

注意在每个函数的前面加上public static extern +返回的数据类型,如果不加public ,函数默认为私有函数，调用就会出错。

在C\#调用C++ 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语言的规范。

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

Win32 Types   
CLR Type

char, INT8, SBYTE, CHAR   
System.SByte

short, short int, INT16, SHORT   
System.Int16

int, long, long int, INT32, LONG32, BOOL , INT   
System.Int32

\_\_int64, INT64, LONGLONG   
System.Int64

unsigned char, UINT8, UCHAR , BYTE   
System.Byte

unsigned short, UINT16, USHORT, WORD, ATOM, WCHAR , \_\_wchar\_t   
System.UInt16

unsigned, unsigned int, UINT32, ULONG32, DWORD32, ULONG, DWORD, UINT   
System.UInt32

unsigned \_\_int64, UINT64, DWORDLONG, ULONGLONG   
System.UInt64

float, FLOAT   
System.Single

double, long double, DOUBLE   
System.Double

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

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

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

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

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

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

dllImport(“ file ”)] extern static int FunctionName(ref byte param1, ref byte param2)

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

在实际的情况中，我们利用参数传递地址更多还是用在传送数组首地址上。   
如：byte\[\] param1 = new param1(6);

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

[DllImport(“ file ”)] extern static int FunctionName(ref byte param1[1], ref byte param2)

C\# 中调用DLL   
为了能用上原来的C++代码，只好研究下从C\# 中调用DLL  
首先必须要有一个声明，使用的是DllImport关键字：   
包含DllImport所在的名字空间

![复制代码][copycode.gif]

using System.Runtime.InteropServices; public class XXXX{ [DllImport(“MyDLL.dll")] 
    public static extern int mySum (int a,int b); } [DllImport(“MyDLL.dll")] 
    public static extern int mySum (int a,int b);

![复制代码][copycode.gif]

代码中DllImport关键字作用是告诉编译器入口点在哪里，并将打包函数捆绑在这个类中   
在调用的时候   
在类中的时候 直接　  mySum(a,b);就可以了   
在其他类中调用: XXXX. mySum(a,b);   
 EntryPoint: 指定要调用的 DLL 入口点。默认入口点名称是托管方法的名称 。   
CharSet: 控制名称重整和封送 String 参数的方式 (默认是UNICODE)   
CallingConvention指示入口点的函数调用约定(默认WINAPI)(上次报告讲过的）   
SetLastError 指示被调用方在从属性化方法返回之前是否调用 SetLastError Win32 API 函数 (C\#中默认false )

int 类型

![复制代码][copycode.gif]

[DllImport(“MyDLL.dll")] 
    //返回个int 类型 
    public static extern int mySum (int a1,int b1); //DLL中申明 
    extern “C” __declspec(dllexport)  int WINAPI mySum(int a2,int b2) { //a2 b2不能改变a1 b1 //a2=.. //b2=...
     return a+b; } //参数传递int 类型 
    public static extern int mySum (ref int a1,ref int b1); //DLL中申明 
    extern “C” __declspec(dllexport)  int WINAPI mySum(int *a2,int *b2) { //可以改变 a1, b1
    *a2=... *b2=... return a+b; } DLL 需传入char *类型 [DllImport(“MyDLL.dll")] 
    //传入值 
    public static extern int mySum (string  astr1,string bstr1); //DLL中申明 
    extern “C” __declspec(dllexport)  int WINAPI mySum(char * astr2,char * bstr2) { //改变astr2 bstr 2 ，astr1 bstr1不会被改变
     return a+b; } DLL 需传出char *类型 [DllImport(“MyDLL.dll")] 
    // 传出值
    public static extern int mySum (StringBuilder abuf, StringBuilder bbuf ); //DLL中申明 
    extern “C” __declspec(dllexport)  int WINAPI mySum(char * astr,char * bstr) { //传出char *　改变astr　bstr -->abuf, bbuf可以被改变
     return a+b; }

![复制代码][copycode.gif]

DLL 回调函数

BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)

![复制代码][copycode.gif]

using System; using System.Runtime.InteropServices; public delegate bool CallBack(int hwnd, int lParam); //定义委托函数类型 
    public class EnumReportApp { [DllImport("user32")] public static extern int EnumWindows(CallBack x, int y); public static void Main() { CallBack myCallBack = new CallBack(EnumReportApp.Report); EnumWindows(myCallBack, 0); } public static bool Report(int hwnd, int lParam) { Console.Write("Window handle is "); Console.WriteLine(hwnd); return true; } }

![复制代码][copycode.gif]

DLL  传递结构    
BOOL PtInRect(const RECT \*lprc, POINT pt);

![复制代码][copycode.gif]

using System.Runtime.InteropServices; [StructLayout(LayoutKind.Sequential)] public struct Point { public int x; public int y; } [StructLayout(LayoutKind.Explicit)] public struct Rect { [FieldOffset(0)] public int left; [FieldOffset(4)] public int top; [FieldOffset(8)] public int right; [FieldOffset(12)] public int bottom; } Class XXXX { [DllImport("User32.dll")] public static extern bool PtInRect(ref Rect r, Point p); }

![复制代码][copycode.gif]

DLL 回调函数，传递结构 想看的msdn里面都有专题介绍，看的我都是晕晕的:)

其他参考请搜索:

在C\#程序设计中使用Win32类库  
C\#中调用C++托管Dll  
如何在C\#中加载自己编写的动态链接库

相关文章：Creating a P/Invoke Library

能用上DLL以后感觉还是很好的，原来的C++代码只要修改编译通过就可以了，  
高兴没多久，发现.net2005居然可以用VB，VC开发智能设备项目，可以创建MFC智能设备项目  
晕晕，难道可以直接用MFC来开发smartphone的程序了，赶紧看看，，，

Visual C++ 使用 \_\_declspec(dllexport) 从 DLL 导出 (到C\#)   
由于各种的原因， 如何把unmanaged 的 c++ DLL 转换成 managed C\# 是一个问题。

方法有3个.

Ø 使用.def文件

Ø 可以不用.def文件, 使用\_\_declspec(dllexport)关键字, 特别是针对Visual C++编译器的时候

Ø 直接用MC++写

什么时候用.def文件?

.def的意思是module-definition， 这个纯文本的文件定义了模块的信息。 对于编译器来说， 一个方法在编译之后的DLL文件里， 存在的形式名字可能不是作者当时起的那个，例如好好的函数名字function() 变成了?function2@@YAXXZ; 可以用undname查看这个被编译器修饰掉的名字, 原型是"void \_\_cdecl function2(void)". 大概使用的时候就会遇到类似”链接错误，未决的外部符号…” 的错误.

.def文件主要的作用, 就是”标注” 出这个函数原来的样子, 这样编译器在编译的时候, 规则上就会以C编译器的规则来处理, 修饰被去掉了, 另外同时可以把导出函数的序号值手动的改高一点; 还有一个优点(也是缺点) 就是可以用NONAME来修饰函数, 这样导出函数的序号值就变成了1~N, 即第N个函数. 所以调用GetProcAddress() 的时候, 可以直接用定义的序号值, 而不用写函数的名字(但是名字就完全不可用了), 更好的是, 导出函数的这个DLL会变得比较小, 当然, MSDN强调了一点: 仅你可以并有权更改这个.def文件内容的时候, 你才可以用这个办法.

那么， 什么时候考虑用.def文件呢? 因为编译器不同, 而产生的修饰名不同的话, 这个文件就是必须的.

注意如果文件没有导出函数的话， 这个文件可能降低运行效率。

.def文件的格式

LIBRARY FileNameWithoutExtension

EXPORTS

Function1 @1

Function3 @2

Function2 @3 NONAME

启用 Enable it: Property pages-> Configuration Properties->C/C++ -> Linker -> input -> Module Definition File

那不用.def呢? \_\_declspec(dllexport)的作用

这个东西, 可以给函数用, 也可以给类用. 声明大概这样子:

view source   
< id="highlighter\_930381\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 \_\_declspec(dllexport) int \_\_stdcall GetMid(vector<type> ve);

2 class \_\_declspec(dllexport) TestClass\{

3 public :

4 TestClass();

5 \}

这牵扯到了一个东西就是\_\_stdcall和\_\_cdecl (还有\_\_fastcall, 不过很少用), 其中\_\_cdecl一般是C或者C++的缺省调用规范, 但是最大的一个区别就是\_\_stdcall在返回前自身清除堆栈, 而\_\_cdecl是调用方来做这个事情(可参考COM中的某些机制), 另一个区别就是\_\_stdcall对于可变参数的函数, 玩不转.

反正今时今日, 大家都在用\_\_stdcall, 所以这么写也没什么问题, 但不是没有. VB里调用标记着\_\_cdecl的方法, 可能会得到一个异常Bad DLL Calling Convention. 解决方法也很简单:

原来的函数

view source   
< id="highlighter\_718220\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 long \_cdecl PassStr(LPSTR pStr)

2 \{       return 1;      \}

新的函数

view source   
< id="highlighter\_515163\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 long \_stdcall PassStrStdCall(LPSTR pStr)

2 \{       return PassStr(pStr);      \}

问题是, 如果这个函数原型, 参数是可变的, 那又怎么弄呢?

调用的时候， C\#都是这么写的：

view source   
< id="highlighter\_120154\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 \[DllImport("", EntryPoint = @" ?GetMid@@YAXXZ", CharSet = CharSet.Auto)\]

2 private static extern void GetMid(...);

这个入口点名字还真别扭， 看来去掉这个修饰还是蛮需要的， 除了用.def文件, 另一个办法就是用 extern “C”.

Extern “C”

一句话总结：这个东西可以去掉修饰名。在不用.def文件的前提下, 这个可以保证你的函数function() 还是这个名字.

但是，这个东西对类不太起作用！

这个东西是这么用的： 放到函数声明的最前面。 就类似这样 extern “C” void \_\_declspec(dllexport) function(void);

对于类， 一般的做法是， 把它的内部方法（特别是实例方法，或变量），wrap出一个方法来。 见下面的实例.

还要做什么？

当一个DLL被初始化的时候， 它需要一个入口点， 一般对于非MFC DLL来说， 这样写就行了：

view source   
< id="highlighter\_702691\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
01 BOOL APIENTRY DllMain(HANDLE hModule,

02                       DWORD  ul\_reason\_for\_call,

03                       LPVOID lpReserved

04                       )

05 \{

06     switch( ul\_reason\_for\_call )

07     \{

08     case DLL\_PROCESS\_ATTACH:

09     case DLL\_THREAD\_ATTACH:

10     case DLL\_THREAD\_DETACH:

11     case DLL\_PROCESS\_DETACH:

12         break;

13     \}

14     return TRUE;

15 \}

要注意的是这个入口点的名字必须是DllMain， 如果不是需要修改linker的/entry 选项. 否则对于C的话可能会初始化失败.

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

开始用导出函数 PInvoke

为了好看一点， 先约定一下：

view source   
< id="highlighter\_95255\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 \#define EXT\_C extern "C"

2 \#define DLLEXPORT \_\_declspec(dllexport)

3 \#define EXT\_C\_DLLEXPORT EXT\_C DLLEXPORT

4 \#define CALLBACK    \_\_stdcall

5 \#define WINAPI      \_\_stdcall

6 \#define APIENTRY    WINAPI

1. 普通的函数

view source   
< id="highlighter\_171056\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 EXT\_C\_DLLEXPORT void WINAPI Function();

3 \[DllImport("filename.dll", EntryPoint = " Function")\]

4 private static extern void Func();

2. ref或者out

view source   
< id="highlighter\_733498\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 EXT\_C\_DLLEXPORT void WINAPI Function(Type\*\* ty);

3 \[DllImport("filename.dll", EntryPoint = " Function")\]

4 private static extern void Func(out Type ty);

3. 指针函数和委托

view source   
< id="highlighter\_987259\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 Typedef void (CALLBACK \*pFunc)(int);

2 EXT\_C\_DLLEXPORT void WINAPI Compare(int a, int b, pFunc p);

3 private delegate int CompareCallback(int a, int b);

4 \[DllImport("filename.dll",EntryPoint=”Compare”)\]

5 private static extern int Compare(int a, int b, CompareCallback call);

4. 类的处理. 其实不是说不可以把类标记为 DLLEXPORT, 如果可以的话, 当然是wrap比较好

C++里的原型

view source   
< id="highlighter\_909839\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 class DLLEXPORT Test

2 \{

3 public :

4     Test();

5     ~Test();

6     BOOL function(int par)

7 \};

类被export， 函数调用时候注意用CallingConvention.ThisCall.

view source   
< id="highlighter\_447728\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 \[DllImport("filename.dll", EntryPoint = @"??4Test@@QEAAAEAV0@AEBV0@@Z", CallingConvention = CallingConvention.ThisCall)\]

2   private static extern int TestFunc(IntPtr hwnd, int par);

采用了”迂回”策略, C++里先这样定义,同理, 添加构造函数等, 函数就变成了这个样子:

view source   
< id="highlighter\_371353\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
01 EXT\_C\_DLLEXPORT BOOL WINAPI function\_wrap(Test\* t, int par)

02 \{

03     return t->function(par);

04 \}

05 EXT\_C\_DLLEXPORT Test\* Test\_ctor()

06 \{

07     Test\* t = new Test();

08     return t;

09 \}

10 EXT\_C\_DLLEXPORT void Test\_dector(Test\* t)

11 \{

12     if(NULL == t)

13     \{

14         delete t;

15         t = NULL;

16     \}

17 \}

在C\#里这样写, 那么就和平时用没什么区别了.

view source   
< id="highlighter\_413990\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
01 public class Test : IDisposable

02         \{

03             private IntPtr instance;

04             public Test()

05             \{

06                 instance = CreateInstance();

07             \}

09              ~Test()

10             \{

11                 Dispose(false);

12             \}

14             \#region pinvoke

15             \[DllImport("filename.dll", EntryPoint = @"Test\_ctor")\]

16             private static extern IntPtr CreateInstance();

17             \[DllImport("filename.dll", EntryPoint = @"Test\_dector")\]

18             private static extern void DestroyInstance(IntPtr hwnd);

19             \[return: MarshalAs(UnmanagedType.Bool)\]

20             \[DllImport("filename.dll", EntryPoint = @"function\_wrap")\]

21             private static extern bool function\_wrap(int par);

22             \#endregion

24             \#region IDisposable Members

26             public void Dispose()

27             \{

28                 Dispose(true);

29             \}

31             private void Dispose(bool bDisposing)

32             \{

33                 if (instance != IntPtr.Zero)

34                 \{

35                     DestroyInstance(instance);

36                 \}

38                 if (bDisposing)

39                 \{

40                     GC.SuppressFinalize(this);

41                 \}

42             \}

44             \#endregion

45         \}

5. Struct操作.

view source   
< id="highlighter\_777150\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 typedef struct Object\_HANDLE \{

2   unsigned long      dbch\_size;

3   HANDLE     dbch\_handle;

4   GUID       dbch\_eventguid;

5   BOOL res\_flag;

6 \} Object\_Native\_HANDLE ;

首先在C\#里严格定义这个，LayoutKind.Sequential 用来保证内存分配的正常。

view source   
< id="highlighter\_876084\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 \[StructLayout(LayoutKind.Sequential)\]

2 public struct Object\_Native\_HANDLE

3 \{

4     public ulong dbch\_size;

5     public IntPtr dbch\_handle;

6     public Guid dbch\_eventGuid;

7     public bool res\_flag;

8 \}

Marshal的使用如下：

view source   
< id="highlighter\_487393\_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\#version=9,0,0,0" type="application/x-shockwave-flash">   
print?  
1 Object\_Native\_HANDLE obj = new Object\_Native\_HANDLE(); //初始化

2 int amountToAllocate = Marshal.SizeOf(obj);//获取大小

3 IntPtr objPtr = Marshal.AllocHGlobal(amountToAllocate); //分配并获取空的空间地址

4 Marshal.StructureToPtr(obj, objPtr, false); // 值写入分配的空间

5 //操作...

6 Marshal.FreeHGlobal(objPtr);//释放空间

最后提一句， unmaged code中的错误， 到managed 以后， 极大可能是捕捉不到的。 所以错误需要分别处理。

花了不少时间， MC++平时用的不多， 不写了。

[C_C_C_.dll_ - CSharp - C]: http://img3.ph.126.net/3IIpePlh7EJkl4MIArrbSQ==/2717077950205500173.jpg
[copycode.gif]: /images/20220823/b03dca942d4442808d258ae4778f586e.png