C#调用C/C++动态库 封送结构体，结构体数组

因为实验室图像处理的算法都是在OpenCV下写的，还有就是导航的算法也是用C++写的，然后界面部分要求在C#下写，所以不管是Socket通信，还是调用OpenCV的DLL模块，都设计到了C#和C++数据类型的对应，还有结构体的封装使用。在夸语言调用方面，Java和C#都只能调用C格式导出的动态库，因为C数据类型比较单一，容易映射，两者都是在本地端提供一套与之映射的C#或者Java的描述接口，通过底层处理这种映射关系达到调用的目的。

 一. 结构体的传递

#define JNAAPI extern "C" __declspec(dllexport) // C方式导出函数 
   
typedef struct     
{   
    int osVersion;   
    int majorVersion;   
    int minorVersion;   
    int buildNum;   
    int platFormId;   
    char szVersion[128];   
}OSINFO;  

//获取版本信息（传递结构体指针）
JNAAPI bool SetVersionPtr(OSINFO *info)
{
	char * str = "Hello DLL";
	info->osVersion = 100;
	strcpy(info->szVersion, str);

	return true;
}
//获取版本信息（传递结构体引用）
JNAAPI bool SetVersionRef(OSINFO &info)
{
	char * str = "Hello DLL";
	info.osVersion = 101;
	strcpy(info.szVersion, str);

	return true;
}

　　

在C#下对应的结构体定义：

// OSINFO定义  
[StructLayout(LayoutKind.Sequential)]  
public struct OSINFO  
{  
    public int osVersion;  
    public int majorVersion;  
    public int minorVersion;  
    public int buildNum;  
    public int platFormId;  
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]  
    public string szVersion;  
}  

　　

可以通过两种方式来调用非托管的函数SetVersionPtr：

1. 方式一（传入结构体引用），在C#中，结构体是以传值的方式传递的，类才是一传地址的方式传递的，加上关键字ref就可以了。C端传递了两种不同类型的参数，都可以通过引用来解决。

[DllImport("jnalib.dll", EntryPoint = "GetVersionPtr")]  
public static extern bool GetVersionPtr(ref OSINFO info);  
public static extern bool GetVersionRef(ref OSINFO info);

　　

2. 方式二(传入IntPtr(平台通用指针))

 对应的函数在C#中的声明：

[DllImport("CSharpInvokeCpp_CppDemo.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool SetVersionPtr(IntPtr pv);

　　　　

测试代码：

IntPtr pv = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OSINFO)));
//对申请的非托管的内存赋值
//但是没有对最后一个string赋值
for (int i = 0; i < 5; i++)
{
	Marshal.WriteInt32(pv, i * Marshal.SizeOf(typeof(Int32)), ((Int32)(i + 1)));
}
	
if (CppDLL.SetVersionPtr(pv))
{
	Console.WriteLine("--osVersion:{0}", Marshal.ReadInt32(pv, 0));
	Console.WriteLine("--Major:{0}", Marshal.ReadInt32(pv, 4));
	Console.WriteLine("--Minor:{0}", Marshal.ReadInt32(pv, 8));
	Console.WriteLine("--BuildNum:{0}", Marshal.ReadInt32(pv, 12));
	Console.WriteLine("--szVersion:{0}", Marshal.PtrToStringAnsi((IntPtr)(pv.ToInt32()+20)));
}
Marshal.FreeHGlobal(pv);

　　

上面的两种方法得区别是：

第一种方法是先创建一个等价的结构体，然后把这个结构体的引用传递给DLL中的接口函数。第二种方法是申请一块结构体大小的非托管内存，然后向内存中写入数据。调用的时候，只把这块非托管的内存的指针传递给DLL中的接口函数。其实第二种方法可以不用事先定义结构体，只需要知道结构体的大小，申请相应的非托管内存就可以了。

二.结构体数组的传递

 DLL中非托管代码：

//传递结构体数组指针
JNAAPI bool SetVersionArray(OSINFO *info, int nLen)
{
	char *str = "Hello DLL";

	for(int i = 0; i < nLen; i++)
	{
		info[i].osVersion = 100;
		strcpy(info[i].szVersion, str);
	}

	return true;
}

调用代码接口：

//C#接口，对于包含数组类型，只能传递IntPtr
[DllImport("CSharpInvokeCpp_CppDemo.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool SetVersionArray(IntPtr pv, int nLen);

测试代码：

//结构体数组的传递测试代码
OSINFO[] infos = new OSINFO[2];
for (int i = 0; i < infos.Length; i++ )
{
	infos[i] = new OSINFO();
}
IntPtr[] ptrArr = new IntPtr[1]; 
ptrArr[0] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OSINFO)) * 2);
IntPtr pt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OSINFO)));

Marshal.Copy(ptrArr, 0, pt, 1);
CppDLL.SetVersionArray(pt, 2);

for (int i = 0; i < infos.Length; i++)
{
	infos[i] = (OSINFO)Marshal.PtrToStructure((IntPtr)(pt.ToInt32() + i * Marshal.SizeOf(typeof(OSINFO))), typeof(OSINFO));
	Console.WriteLine("OsVersion:{0} szVersion:{1}", infos[i].osVersion, infos[i].szVersion);
}

Marshal.FreeHGlobal(ptrArr[0]);
Marshal.FreeHGlobal(pt);

　　上面的代码中有两处需要说明一下：

（1）C#中的IntPtr指针做相应的运算的时候，要首先把IntPtr做相应的转换，然后运算。运算结束之后还要再做相应的转换，还原成原来的IntPtr。

（2）Marshal.Copy这个函数的功能是：将数据从托管数组复制到非托管内存指针，或从非托管内存指针复制到托管数组。

三. 复杂结构体的传递

1. 输出参数,结构体作为指针传出

 非托管部分代码：

typedef struct 
{
	char name[20];
	int age;
	double scores[32];
}Student;

//Class中包含结构体数组类型
typedef struct
{
	int number;
	Student stedents[50];
}Class;

JNAAPI int GetClass(Class *pClass,int len)
{
	for(int i = 0; i < len; i++)
	{
		pClass[i].number = i;
		for(int j = 0; j< 50; j++)
		{
			//把name中的前20个字节用0代替
			memset(pClass[i].stedents[j].name, 0, 20);
			//给每个同学命名
			sprintf(pClass[i].stedents[j].name, "name_%d_%d", i, j);
			pClass[i].stedents[j].age = j % 2 == 0 ? 15:20;
		}//for
	}//for

	return 0;
}

　　

上面DLL 的导出函数要求传递的参数为它自定义的Class结构体数组， 那么我们在C#调用它时也要自定义对应的结构体了，

我们可以定义为如下：

[StructLayout(LayoutKind.Sequential)]
struct Student
{
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 20)]
	public string name;
	public int age;
	[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
	public double[] scores;
}
[StructLayout(LayoutKind.Sequential)]
struct Class
{
	public int number;
	[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
	public Student[] students;

}

　　需要注意的是，这2个结构体中的数组大小一定要跟C++中的限定一样大小哦，接下来如何使用这个API来正确的获取数据呢，大多数人可能想到像这样的处理方式：

Class myclass = new Class();
IntPtr ptr=Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Class)));
GetClass(ptr);
Marshal.FreeHGlobal(ptr);

　　

没错，这样的处理是没问题的，但是我们的API的参数是Class数组，这种处理方式只是传递一个Class结构体参数,所以这种方式在这里就不太合适了，！

 那大家就想到先Class[] myclass = new Class[MaxClass]; 然后在用Marshal.AllocHGlobal 来获取myclass 数据的指针，

其实这样也是错的， 因为 Class结构中包含了，不能直接封送的Student结构，所以无论如何上面的想法是错误的！

那要怎么办呢，其实很简单，就是先分配一段非托管内存，并调用API后，再将非托管内容数据读取到托管结构体数据中！

示例演示代码如下：

// 接口定义   
[DllImport("CSharpInvokeCpp_CppDemo.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int GetClass(IntPtr pv, int len);
//复杂结构体传递测试代码
int size = Marshal.SizeOf(typeof(Class)) * 50;
IntPtr pBuff = Marshal.AllocHGlobal(size);
CppDLL.GetClass(pBuff, 50);

Class[] pClass = new Class[50];
for (int i = 0; i < 50; i++)
{
	IntPtr pr = new IntPtr(pBuff.ToInt64() + Marshal.SizeOf(typeof(Class)) * i);
	pClass[i] = (Class)Marshal.PtrToStructure(pr, typeof(Class));
}
Marshal.FreeHGlobal(pBuff);

　　

5月19日学习内容：

http://tcspecial.iteye.com/blog/1675621

http://www.cnblogs.com/naiking/archive/2013/01/17/2864132.html

http://blog.csdn.net/zhangj1012003_2007/article/details/6283032

http://blog.csdn.net/xiaowei_cqu/article/details/7693985