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

因为公司一直都是做C++开发的,因客户需要要提供C#版本接口,研究了一下C#,发现其强大简洁, 在跨语言调用方面封装的很彻底,提供了强大的API与之交互.这点比JNA方便多了. java与C#都只能调用C格式导出动态库,因为C数据类型比较单一,容易映射. 两者都是在本地端提供一套与之映射的C#/java描述接口,通过底层处理这种映射关系达到调用的目的.

一.结构体的传递

1. #defineJNAAPIextern"C"__declspec(dllexport)//C方式导出函数
3. typedefstruct
4. {
5. intosVersion;
6. intmajorVersion;
7. intminorVersion;
8. intbuildNum;
9. intplatFormId;
10. charszVersion[128];
11. }OSINFO;
13. //1.获取版本信息(传递结构体指针)
14. JNAAPIboolGetVersionPtr(OSINFO*info);
15. //2.获取版本信息(传递结构体引用)
16. JNAAPIboolGetVersionRef(OSINFO&info);

可以通过二种方式来调用:

1. //OSINFO定义
2. [StructLayout(LayoutKind.Sequential)]
3. publicstructOSINFO
4. {
5. publicintosVersion;
6. publicintmajorVersion;
7. publicintminorVersion;
8. publicintbuildNum;
9. publicintplatFormId;
10. [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)]
11. publicstringszVersion;
12. }

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

1. [DllImport("jnalib.dll",EntryPoint="GetVersionPtr")]
2. publicstaticexternboolGetVersionPtr(refOSINFOinfo);
3. publicstaticexternboolGetVersionRef(refOSINFOinfo);

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

1. IntPtrpv=Marshal.AllocHGlobal(148);//结构体在使用时一定要分配空间(4*sizeof(int)+128)
2. Marshal.WriteInt32(pv,148);//向内存块里写入数值
3. if(GetVersionPtr(pv))//直接以非托管内存块地址为参数
4. {
5. Console.WriteLine("--osVersion:{0}",Marshal.ReadInt32(pv,0));
6. Console.WriteLine("--Major:{0}",Marshal.ReadInt32(pv,4));//移动4个字节
7. Console.WriteLine("--BuildNum:"+Marshal.ReadInt32(pv,12));
8. Console.WriteLine("--szVersion:"+Marshal.PtrToStringAnsi((IntPtr)(pv.ToInt32()+20)));
9. }
10. Marshal.FreeHGlobal(pv);//处理完记得释放内存

二.结构体数组的传递

1. //传递结构体指针
2. JNAAPIboolGetVersionArray(OSINFO*info,intnLen);

调用代码:

1. /**
2. *C#接口,对于包含数组类型,只能传递IntPtr
3. */
4. [DllImport("jnalib.dll",EntryPoint="GetVersionArray")]
5. publicstaticexternboolGetVersionArray(IntPtrp,intnLen);
7. //源目标参数
8. OSINFO[]infos=newOSINFO[2];
9. for(inti=0;i<infos.Length;i++)
10. {
11. infos[i]=newOSINFO();
12. }
14. IntPtr[]ptArr=newIntPtr[1];
15. ptArr[0]=Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OSINFO))*2);//分配包含两个元素的数组
16. IntPtrpt=Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OSINFO)));
17. Marshal.Copy(ptArr,0,pt,1);//拷贝指针数组
18. GetVersionArray(pt,2);//调用
20. //还原成结构体数组
21. for(inti=0;i<2;i++)
22. {
23. infos[i]=(OSINFO)Marshal.PtrToStructure((IntPtr)(pt.ToInt32()+i*Marshal.SizeOf(typeof(OSINFO))),typeof(OSINFO));
24. Console.WriteLine("OsVersion:{0}szVersion:{1}",infos[i].osVersion,infos[i].szVersion);
25. }

三.复杂结构体的传递

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

1. typedefstruct
2. {
3. charname[20];
4. intage;
5. doublescores[30];
6. }Student;
8. //Class中包含结构体数组类型
9. typedefstruct
10. {
11. intnumber;
12. Studentstudents[50];
13. }Class;
15. //传入复杂结构体测试
16. JNAAPIintGetClass(Class*pClass,intlen);

1. //接口定义
2. [DllImport("jnalib.dll",EntryPoint="GetClass")]
3. publicstaticexternintGetClass(IntPtrpv,intlen);
5. //结构体定义
6. //Student
7. [StructLayout(LayoutKind.Sequential)]
8. publicstructStudent
9. {
10. [MarshalAs(UnmanagedType.ByValTStr,SizeConst=20)]
11. publicstringname;
12. publicintage;
13. [MarshalAs(UnmanagedType.ByValArray,SizeConst=30)]
14. publicdouble[]scores;
15. }
17. //Class
18. [StructLayout(LayoutKind.Sequential)]
19. publicstructClass
20. {
21. publicintnumber;
22. [MarshalAs(UnmanagedType.ByValArray,SizeConst=50)]//指定数组尺寸
23. publicStudent[]students;//结构体数组定义
24. }
26. //调用复杂结构体测试
27. intsize=Marshal.SizeOf(typeof(Class))*50;
28. IntPtrpBuff=Marshal.AllocHGlobal(size);//直接分配50个元素的空间,比Marshal.copy方便多了
29. GetClass(pBuff,50);
31. Class[]pClass=newClass[50];
32. for(inti=0;i<50;i++)
33. {
34. IntPtrptr=newIntPtr(pBuff.ToInt64()+Marshal.SizeOf(typeof(Class))*i);
35. pClass[i]=(Class)Marshal.PtrToStructure(ptr,typeof(Class));
36. }
37. Marshal.FreeHGlobal(pBuff);//释放内存

2. 输入参数, 给复杂结构体赋值后作为输入参数传入

对于比较大的结构体指针,无法直接应用结构体类型,转化成IntPtr类型, 此时需要将原生类型转化为指针,并给指针赋值

调用方法: Marshal.StructureToPtr(stu, ptr1, true)