转：c#类型调用转换

最近在编写Warensoft3D游戏引擎，并预计明年年初发布测试版本，底层引擎使用DirectX和MONO来编写，上层的逻辑使用C#来编写，因此编写了大量C#与C++互调的代码，现在经验写出来与大家分享，并希望后来者少走弯路。

C#与C++交互，总体来说可以有两种方法：

利用C++/CLI作为代理中间层利用PInvoke实现直接调用

第一种方法：实现起来比较简单直观，并且可以实现C#调用C++所写的类，但是问题是MONO构架不支持C++/CLI功能，因此无法实现脱离Microsoft .NET Framework跨平台运行。

第二种方法：简单的实现并不麻烦，只要添加DllImportAttribute特性即可以导入C/C++的函数，但是问题是PInvoke不能简单的实现对C++类的调用。在Warensoft3D中为了可以使用MONO实现跨平台（当然DirectX是不能跨平台的），所以使用了本方法，下面将对本方法展开详细的说明。

测试平台：

Windows7 64位，VS2010，.NET4.0

注意事项：

PInvoke从功能上来说，只支持函数调用，在被导出的函数前面一定要添加extern "C"来指明导出函数的时候使用C语言方式编译和连接，这样保证函数定义的名字和导出的名字相同，否则如果默认按C++方式导出，那个函数的名字就会变得乱七八糟，我们的程序就无法找到入口点了。

本文将说明以下几点：

互调的基本原理基本数据类型的传递指针的传递函数指针的传递结构体的传递

?

?

互调的基本原理

首先，我们来看一个再常规不过的概念—"数据类型"

我们知道在大多数的静态语言中定义变量的时候都要先指定其数据类型，所谓数据类型，都是人们强加的一个便于记忆的名称，究其本质就是指明了这个数据在内存里到底是占用了几个字节，程序在运行的时候，首先找到这个数据的地址，然后再按着该类型的长度，读取相对应的内存，然后再处理。

了解了前面这个事儿，所有编程语言之间进行互调就有点门道儿了。对于不同语言之间的互调，只要将该数据的指针（内存地址）传递给另一个语言，在另一个语言中根据通信协议将指针所指向的数据存储入长度对应的数据类型即可，当然要满足以下几点：

对于像Java，.NET这样有运行时虚拟机编程语言来讲，由于虚拟机会让堆内存来回转移，因此，在进行互调的时候，要保证正在被互调的数据所在的内存一定要固定，不能被转移。有一些编程语言支持指针，有一些语言不支持指针（如Java），这个问题并不重要，所谓指针，其实就是一个内存地址，对于32位OS的指针是一个32位整数，而对于64位机OS的指针是一个64位整数。因为大多数语言中都有整型数，所以可以利用整型来接收指针。
基本数据类型的传递

互调过程中，最基本要传递的无非是数值和字符，即：int,long,float,char等等，但是此类型非彼类型，C/C++与C#中有一些数据类型长度是不一样的，下表中列出常见数据类型的异同：

C/C++?

C#?

长度

short?

short?

2Bytes

int

int?

4Bytes?

long(该类型在传递的时候常常会弄混)

int?

4Bytes?

bool?

bool?

1Byte?

char(Ascii码字符)

byte?

1Byte?

wchar_t（Unicode字符，该类型与C#中的Char兼容）

char?

2Bytes?

float

float

4Bytes

double?

double?

8Bytes?

最容易弄混的是就是long,char两个类型，在C/C++中long和int都是4个字节，都对应着C#中的int类型，而C/C++中的char类型占一个字节，用来表示一个ASCII码字符，在C#中能够表示一个字节的是byte类型。与C#中char类型对应的应该是C/C++中的wchar_t类型，对应的是一个2字节的Unicode字符。

下面通过实例来说明调用过程：

第一步：

建立一个C++的Win32DLL，如下图所示：



这里要注意选择"Export symbols"导出符号。点击完成。

第二步：

由于项目的名称是"TestCPPDLL"，因此，会自动生成TestCPPDLL.h和TestCPPDLL.cpp两个文件，.h文件是要导出内容的声明文件，为了能清楚的说明问题，我们将TestCPPDLL.h和TestCPPDLL.cpp两个文件中的所有内容都删除，然后在TestCPPDLL.h中添加如下内容：



第一行代码中定义了一个名为"TESTCPPDLL_API"的宏，该宏对应的内容是"__declspec(dllexport)"意思是将后面修饰的内容定义为DLL中要导出的内容。当然你也可以不使用这个宏，可以直接将"__declspec(dllexport)"写在要导出的函数前面。

第二行中的"EXTERN_C"，是在"winnt.h"中定义的宏，在函数前面添加"EXTERN_C"等同于在函数前面添加extern "C",意思是该函数在编译和连接时使用C语言的方式，以保证函数名字不变。

第二行的代码是一个函数的声明，说明该函数可以被模块外部调用，其定义实现在TestCPPDLL.cpp中，TestCPPDLL.cpp的代码如下所示：



第三步：

在编译C++DLL之前，需要做以下配置，在项目属性对话框中选择"C/C++"|"Advanced"，将Compile AS 选项的值改为"C++"。然后确定，并编译。



生成的DLL文件如下图所示：



第四步：

首先，添加一个C#的应用程序，如果要在C#中调用C++的DLL文件，先要在C#的类中添加一个静态方法，并且使用DllImportAttribute对该方法进行修饰，代码如下所示：



DllImport中的第一个参数是指明DLL文件的位置，第二个参数"EntryPoint"用来指明对应的C/C++中的函数名称是什么。"extern"关键字表明该处声明的这个Add方法是一个外部调用。

该方法声明完毕之后，就可以像调用一个普通的静态方法一样去使用了。

下面是示例程序：

class Program

{

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "Add")]

extern static int Add(int a, int b);

static void Main(string[] args)

{

int c = Add(1,2);

Console.WriteLine(c);

Console.Read();

}

}

在运行C#程序之前，先要修改C#的项目属性，如下图所示：



将platform target设置为x86,并且允许非安全代码（后面有用）。

然后运行该C#程序，其结果如下图所示：



第五步：

前面的Add方法中传递的是数值类型（int），其他的数据类型，如float,double,和bool类型的传递方式是一样的，下面演示如何传递字符串。

在TestCPPDLL.h中添加一个新的函数声明，代码如下：

EXTERN_C TESTCPPDLL_API void __stdcall WriteString(wchar_t*content);

这里的参数是wchar_t类型的指针，对应着C#中的char类型。TestCPPDLL.cpp中添加如下代码：

TESTCPPDLL_API void __stdcall WriteString(wchar_t*content)

{

????cout<<content;

}

该代码的功能就是将输入的字符串通过C++在控制台上输出。下面是在C#中的声明:

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "WriteString")]

extern unsafe static void WriteString(char*c);

调用过程如下所示：

//因为使用指针，因为要声明非安全域

unsafe

{

//在传递字符串时，将字符所在的内存固化，

//并取出字符数组的指针

fixed (char* p = &("hello".ToCharArray()[0]))

{

//调用方法

WriteString(p);

}

}

?

其运行效果如下图所示：



?3.?指针的传递

根据前面介绍的数据类型对照表，我们可以直接在方法中传递指针，但是要注意的是我们常常需要将数组的指针（数据入口地址，第一个元素的地址），数据从C/C++到C#时问题不大，但是如果从C#到C/C++时一定要将数组先固化，然后再传递处理。

下面演示如何传递指针，首先在TestCPPDLL.h中添加下列声明：

//传入一个整型指针，将其所指向的内容加1

EXTERN_C TESTCPPDLL_API void __stdcall AddInt(int *i);

//传入一个整型数组的指针以及数组长度，遍历每一个元素并且输出

EXTERN_C TESTCPPDLL_API void __stdcall AddIntArray(int *firstElement,int arraylength);

//在C++中生成一个整型数组，并且数组指针返回给C#

EXTERN_C TESTCPPDLL_API int* __stdcall GetArrayFromCPP();

其实现写在TestCPPDLL.cpp中，代码如下所示：

TESTCPPDLL_API void __stdcall AddInt(int *i)

{

????(*i)++;

}

TESTCPPDLL_API void __stdcall AddIntArray(int *firstElement,int arrayLength)

{

????int*currentPointer=firstElement;

????for (int i = 0; i < arrayLength; i++)

????{

????????cout<<*currentPointer;

????????currentPointer++;

????}

????cout<<endl;

}

?

int *arrPtr;

TESTCPPDLL_API int* __stdcall GetArrayFromCPP()

{

????arrPtr=new int[10];

????

????for (int i = 0; i < 10; i++)

????{

????????arrPtr[i]=i;

????}

????

????return arrPtr;

}

?

对应调用的C#代码如下所示：

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "AddInt")]

extern unsafe static void AddInt(int* i);

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "AddIntArray")]

extern unsafe static void AddIntArray(int* firstElement, int arraylength);

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "GetArrayFromCPP")]

extern unsafe static int* GetArrayFromCPP();

调用过程如下所示：

unsafe

{

// 调用C++中的AddInt方法

int i = 10;

?

AddInt(&i);

Console.WriteLine(i);

?

//调用C++中的AddIntArray方法将C#中的数据传递到C++中，并在C++中输出

int[] CSArray = new int[10];

for (int iArr = 0; iArr < 10; iArr++)

{

CSArray[iArr] = iArr;

}

fixed (int* pCSArray = &CSArray[0])

{

AddIntArray(pCSArray, 10);

}

//调用C++中的GetArrayFromCPP方法获取一个C++中建立的数组

int* pArrayPointer = null;

pArrayPointer = GetArrayFromCPP();

for (int iArr = 0; iArr < 10; iArr++)

{

Console.WriteLine(*pArrayPointer);

pArrayPointer++;

}

}

4. 函数指针的传递

前面说明的都是简单数据类型的及其指针的传递，利用PInvoke我们也可以实现函数指针的传递，C#中并没有函数指针的概念，但是可以使用委托（delegate）来代替函数指针，关于C#中委托的说明，可以参考笔者前面的一个文章：《C#委托及事件》

大家可能会问，为什么要传递函数指针呢？利用PInvoke可以实现C#对C/C++函数的调用，反过来，我们能不能在C/C++程序运行的某一时刻，来调用一个C#对应的函数呢？（例如在C++中存在一个独立线程，该线程可能在任意时刻触发一个事件，并且需要通知C#）。这个时候，我们就有必要将一个C#中已经指向某一个函数的函数指针（委托）传递给C++。

想要传递函数指针，首先要在C#中定义一个委托，并且在C++中定义一个函数指针，同时要保证委托和函数指针具备相同的函数原型，我们首先编写C#的代码，如下所示：

//定义一个委托，返回值为空，存在一个整型参数

public delegate void CSCallback(int tick);

//定义一个用于回调的方法，与前面定义的委托的原型一样

//该方法会被C++所调用

static void CSCallbackFunction(int tick)

{

Console.WriteLine(tick.ToString ());

}

//定义一个委托类型的实例，

//在主程序中该委托实例将指向前面定义的CSCallbackFunction方法

static CSCallback callback;

?

在CS的主程序中让callback指向CSCallbackFunction方法，代码如下所示：

//调用委托所指向的方法

callback = CSCallbackFunction;

?

?

然后在C/C++中定义一个函数指针，并且添加一个用于设置函数指针的函数，TestCPPDLL.h中的代码如下所示：

//定义一个函数指针

typedef void (__stdcall *CPPCallback)(int tick);

//定义一个用于设置函数指针的方法,

//并在该函数中调用C#中传递过来的委托

EXTERN_C TESTCPPDLL_API void SetCallback(CPPCallback callback);

SetCallback函数的实现在TestCPPDLL.cpp中，代码如下所示：

TESTCPPDLL_API void SetCallback(CPPCallback callback)

{

????int tick=rand();

????//下面的代码是对C#中委托进行调用

????callback(tick);

}

在C#中添加SetCallback函数的声明，代码如下所示：

//这里使用CSCallback委托类型来兼容C++里的CPPCallback函数指针

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "SetCallback")]

extern static void SetCallback(CSCallback callback);

在C#中的调用过程如下所示：

//让委托指向将被回调的方法

callback = CSCallbackFunction;

//将委托传递给C++

SetCallback(callback);

SetCallback方法被执行后，在C#中定义的CSCallbackFunction就会被C++所调用。

5. 结构体的传递

传递结构体的想法和传递一个int类型数据类似，struct中的数据是在内存中顺序排列的，只要保证保证以下几点，就可以直接传递结构体，甚至是结构体的指针：

要传递的成员为公有的值类型字段C#中结构体字段类型与C++结构体中的字段类型相兼容C#结构中的字段顺序与C++结构体中的字段顺序相同，要保证该功能，需要将C#结构体标记为[StructLayout( LayoutKind.Sequential)]

下面通过代码进行说明，首先在C#中添加一个结构体，代码如下所示：

[StructLayout( LayoutKind.Sequential)]

struct Vector3

{

public float X, Y, Z;

}

该结构体表示一个3D向量，包括X，Y，Z三个float类型的分量。

然后在TestCPPDLL.h中也定义一个相同结构的结构体，代码如下所示：

struct Vector3

{

????float X,Y,Z;

};

在TestCPPDLL.h中声明一个用于传递Vector3结构体的一个函数，代码如下所示：

EXTERN_C TESTCPPDLL_API void __stdcall SendStructFromCSToCPP(Vector3 vector);

在TestCPPDLL.cpp中将其实现，代码如下所示：

TESTCPPDLL_API void __stdcall SendStructFromCSToCPP(Vector3 vector)

{

????cout<<"got vector3 in cpp,x:";

????cout<<vector.X;

????cout<<",Y:";

????cout<<vector.Y;

????cout<<",Z:";

????cout<<vector.Z;

}

在C#中添加对SendStructFromCSToCPP函数的声明，代码如下所示：

[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "SendStructFromCSToCPP")]

extern static void SendStructFromCSToCPP(Vector3 vector);

C#中的调用过程如下所示：

//建立一个Vector3的实例

Vector3 vector = new Vector3() { X =10,Y=20,Z=30 };

//将vector传递给C++并在C++中输出

SendStructFromCSToCPP(vector);

基输出效果如下所示：



?

完整的TestCPPDLL.h代码如下所示：

?

#define TESTCPPDLL_API __declspec(dllexport)EXTERN_C TESTCPPDLL_API int __stdcall Add(int a,int b);EXTERN_C TESTCPPDLL_API void __stdcall WriteString(wchar_t*content);//传入一个整型指针，将其所指向的内容加1EXTERN_C TESTCPPDLL_API void __stdcall AddInt(int *i);//传入一个整型数组的指针以及数组长度，遍历每一个元素并且输出EXTERN_C TESTCPPDLL_API void __stdcall AddIntArray(int *firstElement,int arraylength);//在C++中生成一个整型数组，并且数组指针返回给C#EXTERN_C TESTCPPDLL_API int* __stdcall GetArrayFromCPP(); //定义一个函数指针typedef void (__stdcall *CPPCallback)(int tick);//定义一个用于设置函数指针的方法,//并在该函数中调用C#中传递过来的委托EXTERN_C TESTCPPDLL_API void __stdcall SetCallback(CPPCallback callback); struct Vector3{    float X,Y,Z;};EXTERN_C TESTCPPDLL_API void __stdcall SendStructFromCSToCPP(Vector3 vector);



?

?

完整的TestCPPDLL.CPP代码如下所示：

?

#include "stdafx.h"#include <iostream>#include "TestCPPDLL.h"using namespace std;TESTCPPDLL_API int __stdcall Add(int a,int b){    return a+b;}TESTCPPDLL_API void __stdcall WriteString(wchar_t*content){    wprintf(content);    printf("\n");} TESTCPPDLL_API void __stdcall AddInt(int *i){    (*i)++;} TESTCPPDLL_API void __stdcall AddIntArray(int *firstElement,int arrayLength){    int*currentPointer=firstElement;    for (int i = 0; i < arrayLength; i++)    {        cout<<*currentPointer;        currentPointer++;    }    cout<<endl;}int *arrPtr;TESTCPPDLL_API int* __stdcall GetArrayFromCPP(){    arrPtr=new int[10];        for (int i = 0; i < 10; i++)    {        arrPtr[i]=i;    }        return arrPtr;} TESTCPPDLL_API void __stdcall SetCallback(CPPCallback callback){    int tick=100;    //下面的代码是对C#中委托进行调用    callback(tick);} TESTCPPDLL_API void __stdcall SendStructFromCSToCPP(Vector3 vector){    cout<<"got vector3 in cpp,x:";    cout<<vector.X;    cout<<",Y:";    cout<<vector.Y;    cout<<",Z:";    cout<<vector.Z;}



?

?

?

完整的C#代码如下所示：

?

using System;using System.Collections.Generic;using System.Runtime.InteropServices;using System.Text; namespace ConsoleApplication1{class Program{[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "Add")]extern static int Add(int a, int b);[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "WriteString")]extern unsafe static void WriteString(char* c);[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "AddInt")]extern unsafe static void AddInt(int* i);[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "AddIntArray")]extern unsafe static void AddIntArray(int* firstElement, int arraylength);[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "GetArrayFromCPP")]extern unsafe static int* GetArrayFromCPP();   //定义一个委托，返回值为空，存在一个整型参数public delegate void CSCallback(int tick);//定义一个用于回调的方法，与前面定义的委托的原型一样//该方法会被C++所调用static void CSCallbackFunction(int tick){Console.WriteLine(tick.ToString()); }//定义一个委托类型的实例，//在主程序中该委托实例将指向前面定义的CSCallbackFunction方法static CSCallback callback;  //这里使用CSCallback委托类型来兼容C++里的CPPCallback函数指针[DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "SetCallback")]extern static void SetCallback(CSCallback callback); [StructLayout(LayoutKind.Sequential)]struct Vector3{public float X, Y, Z;} [DllImport(@"E:\ex\TestCPPDLL\Debug\TestCPPDLL.dll", EntryPoint = "SendStructFromCSToCPP")]extern static void SendStructFromCSToCPP(Vector3 vector); static void Main(string[] args){int c = Add(1, 2);Console.WriteLine(c);//因为使用指针，因为要声明非安全域unsafe{//在传递字符串时，将字符所在的内存固化，//并取出字符数组的指针fixed (char* p = &("hello".ToCharArray()[0])){//调用方法WriteString(p);} }unsafe{// 调用C++中的AddInt方法int i = 10; AddInt(&i);Console.WriteLine(i); //调用C++中的AddIntArray方法将C#中的数据传递到C++中，并在C++中输出int[] CSArray = new int[10];for (int iArr = 0; iArr < 10; iArr++){CSArray[iArr] = iArr;}fixed (int* pCSArray = &CSArray[0]){AddIntArray(pCSArray, 10);}//调用C++中的GetArrayFromCPP方法获取一个C++中建立的数组int* pArrayPointer = null;pArrayPointer = GetArrayFromCPP();for (int iArr = 0; iArr < 10; iArr++){Console.WriteLine(*pArrayPointer);pArrayPointer++;}}    //让委托指向将被回调的方法callback = CSCallbackFunction;//将委托传递给C++SetCallback(callback); //建立一个Vector3的实例Vector3 vector = new Vector3() { X = 10, Y = 20, Z = 30 };//将vector传递给C++并在C++中输出SendStructFromCSToCPP(vector);  Console.Read();}}}

?
41?for(int i=0; i< len -1 ;i++) outHello[i] = TEXT('a');
42    outHello[len -1] = TEXT('\0');
43}

?

?

?

下面看C#如何调用。

?

第一：字符串指针作为输入参数，可以使用byte[] 和MarshalAs来解决。（注意四个P-INVOKE，两个ANSI版本,和两个UNICODE版本），推荐使用MarshalAs方法简单明了。

?

 1        [DllImport("TestDll", EntryPoint ="PrintString")]
 2publicstaticexternvoid PrintStringByBytes(byte[] hello);
 3
 4        [DllImport("TestDll", EntryPoint ="PrintString")]
 5publicstaticexternvoid PrintStringByMarshal([MarshalAs(UnmanagedType.LPStr)]string hello);
 6
 7        [DllImport("TestDll", EntryPoint ="PrintStringW")]
 8publicstaticexternvoid PrintStringByBytesW(byte[] hello);
 9
10        [DllImport("TestDll", EntryPoint ="PrintStringW")]
11publicstaticexternvoid PrintStringByMarshalW([MarshalAs(UnmanagedType.LPWStr)]string hello);
12
13
14publicvoid Run()
15        {
16            PrintStringByBytes(Encoding.ASCII.GetBytes("use byte[]"));
17            PrintStringByMarshal("use MarshalAs");
18            PrintStringByBytesW(Encoding.Unicode.GetBytes("use byte[]"));
19            PrintStringByMarshalW("use MarshalAs");
20}

?

?

?

第二：字符串指针作为返回值，和上面一样也有两种声明方法，同样也包含两个版本。注意：Marshal.PtrToStringAnsi()函数的使用，把字符串指针转变为C#的string.推荐使用MarshalAs方法简单明了。

?

 1        [DllImport("TestDll", EntryPoint ="GetStringReturn")]
 2publicstaticextern IntPtr GetStringReturnByBytes();
 3
 4        [DllImport("TestDll", EntryPoint ="GetStringReturn")]
 5        [return:MarshalAs(UnmanagedType.LPStr)]
 6publicstaticexternstring GetStringReturnByMarshal();
 7
 8        [DllImport("TestDll", EntryPoint ="GetStringReturnW")]
 9publicstaticextern IntPtr GetStringReturnByBytesW();
10
11        [DllImport("TestDll", EntryPoint ="GetStringReturnW")]
12        [return: MarshalAs(UnmanagedType.LPWStr)]
13publicstaticexternstring GetStringReturnByMarshalW();
14
15
16publicvoid Run()
17        {          //Marshal.PtrToStringAuto(GetStringReturnByBytes()); 自动判断类型不错。
18?            Console.WriteLine(Marshal.PtrToStringAnsi(GetStringReturnByBytes()));
19            Console.WriteLine(GetStringReturnByMarshal());
20            Console.WriteLine(Marshal.PtrToStringUni(GetStringReturnByBytesW()));
21            Console.WriteLine(GetStringReturnByMarshalW());
22}

?

?

?

第三：字符串指针作为输入输出参数时，因为要求有固定的容量，所以这里使用的是StringBuilder，大家仔细看了，当然也有byte[]版本。这个看大家喜欢那个版本就是用那个.

?

 1        [DllImport("TestDll", EntryPoint ="GetStringParam")]
 2publicstaticexternvoid GetStringParamByBytes(byte[] outHello, int len);
 3
 4        [DllImport("TestDll", EntryPoint ="GetStringParam")]
 5publicstaticexternvoid GetStringParamByMarshal([Out, MarshalAs(UnmanagedType.LPStr)]StringBuilder outHello, int len);
 6
 7        [DllImport("TestDll", EntryPoint ="GetStringParamW")]
 8publicstaticexternvoid GetStringParamByBytesW(byte[] outHello, int len);
 9
10        [DllImport("TestDll", EntryPoint ="GetStringParamW")]
11publicstaticexternvoid GetStringParamByMarshalW([Out, MarshalAs(UnmanagedType.LPWStr)]StringBuilder outHello, int len);
12
13
14publicbyte[] _outHello =newbyte[10];
15publicbyte[] _outHelloW =newbyte[20];
16public StringBuilder _builder =new StringBuilder(10); //很重要设定string的容量。
17?
18publicvoid Run()
19        {
20//
21?            GetStringParamByBytes(_outHello, _outHello.Length);
22            GetStringParamByMarshal(_builder, _builder.Capacity);
23            GetStringParamByBytesW(_outHelloW, _outHelloW.Length /2);
24            GetStringParamByMarshalW(_builder, _builder.Capacity);
25
26//
27?            Console.WriteLine(Encoding.ASCII.GetString(_outHello));
28            Console.WriteLine(_builder.ToString());
29            Console.WriteLine(Encoding.Unicode.GetString(_outHelloW));
30            Console.WriteLine(_builder.ToString());
31}

class?MyMathFuncs
{
public:
????//?Returns?a?+?b
????static?__declspec(dllexport)?double?Add(double?a,?double?b);

????//?Returns?a?-?b
????static?__declspec(dllexport)?double?Subtract(double?a,?double?b);

????//?Returns?a?*?b
????static?__declspec(dllexport)?double?Multiply(double?a,?double?b);

????//?Returns?a?/?b
????//?Throws?DivideByZeroException?if?b?is?0
????static?__declspec(dllexport)?double?Divide(double?a,?double?b);
};

cxyMath.cpp的实现就很简单了,代码附在上传的文件中,在这里就不贴代码了,编译成dll后,拷贝dll,lib文件到C#的工程中的debug的目录下(如果你写的是release版,请将dll,lib拷贝到relase文件夹下)

第二步:找出导出的函数名
写成如下形式,方便CS的调用
不采用def文件导出的函数名有些奇怪,但还是可以看出函数的层次,?函数名@类名@命名空间@@******,
找函数名可以使用ultraedit32,打开lib文件,就可看到了
另外,我们可以使用dllexp这个程序找出导出的函数(这个程序见附录)

[DllImport("cppdll.dll",EntryPoint="?Divide@MyMathFuncs@MathFuncs@@SANNN@Z",CharSet?=?CharSet.Auto)]
public?static?extern?double?Divide(double?a,double?b);

[DllImport("cppdll.dll",EntryPoint="?Multiply@MyMathFuncs@MathFuncs@@SANNN@Z",CharSet?=?CharSet.Auto)]
public?static?extern?double?Multiply(double?a,double?b);

?第三步,调用

private?void?button1_Click(object?sender,?System.EventArgs?e)
{
????MessageBox.Show(Multiply(12,13).ToString());
}

采用def 文件导出函数

第一种方式比较简单,但是找一个dll函数的入口地址,还是比较麻烦的,并且,入口地址没有太大的意义,不直观,不好记忆

一般情况下,我们可以选择使用def文件导出函数

第一步,新建一个win32 application然后在应用程序的设置中选择动态dll,然后选择导出符号,这样,vs2003就为我们生成了一个非常完整的架子,但是美中不足的是生成的dll导出的函数也是和第一中情况一样

第二步,添加一个def文件,生成def文件的同时,vs2003自动为我们添加了这样一行,
LIBRARY?win32dll

我们只要在他的下面加上我们要导出的函数就可以了.
?? GetAName?? @1
?? ShowMyName @2
?? PerfTest?? @3

这样经过编译我们使用dllexp查看,看到的就不再是一些没有意义的函数名了,而是我们在def中定义的文件函数名

第三步,拷贝lib,dll文件到CS工程中就可以了,
我们就不在这里一一叙述了

刚才我们写的dll同样也可以为C++的工程调用
第一步:新建一个console的C++ application
第二步:添加引用,引用C++ dll application
第三步:拷贝c++ dll的.h文件到console app的目录下,并添加到console app中
第四步:#include "cxyMath.h"
调用就可以了


详情见代码

C#调用C++生成的dll例子,文件中共包含四个工程文件:

cppdll是不使用def文件导出dll函数的示例
win32dll是使用def文件导出dll函数的示例
CsApp是C#一个工程文件,用来调用C++的dll
dlltest是C++调用C++dll的一个示例

代码:http://dl2.csdn.net/down4/20070725/25180037196.rar

dllexp:查看dll导出的一个小程序

http://www.nirsoft.net/utils/dll_export_viewer.html

看了这篇文章后，就知道如何去调用了，但还有一些问题，比如C#的一些类型和C++的类型是不同的

比如C++中的string和C#中的string是不一样的