C#调用C++封装的DLL传递结构体数组的终极解决方案

在项目开发时，要调用C++封装的DLL，普通的类型C#上一般都对应，只要用DllImport传入从DLL中引入函数就可以了。但是当传递的是结构体、结构体数组或者结构体指针的时候，就会发现C#上没有类型可以对应。这时怎么办，第一反应是C#也定义结构体，然后当成参数传弟。然而，当我们定义完一个结构体后想传递参数进去时，会抛异常，或者是传入了结构体，但是返回值却不是我们想要的，经过调试跟踪后发现，那些值压根没有改变过，代码如下。

[csharp]  view plain copy

1. [DllImport("workStation.dll")]  
2.        private static extern bool fetchInfos(Info[] infos);  
3.        public struct Info  
4.        {  
5.            public int OrderNO;  
6.   
7.            public byte[] UniqueCode;  
8.   
9.            public float CpuPercent;                    
10.   
11.        };  
12.        private void buttonTest_Click(object sender, EventArgs e)  
13.        {  
14.            try  
15.            {  
16.             Info[] infos=new Info[128];  
17.                if (fetchInfos(infos))  
18.                {  
19.                    MessageBox.Show("Fail");  
20.                }  
21.             else  
22.             {  
23.                    string message = "";  
24.                    foreach (Info info in infos)  
25.                    {  
26.                        message += string.Format("OrderNO={0}\r\nUniqueCode={1}\r\nCpu={2}",  
27.                                               info.OrderNO,  
28.                                               Encoding.UTF8.GetString(info.UniqueCode),  
29.                                               info.CpuPercent  
30.                                               );  
31.                    }  
32.                    MessageBox.Show(message);  
33.             }  
34.            }  
35.            catch (System.Exception ex)  
36.            {  
37.                MessageBox.Show(ex.Message);  
38.            }  
39.        }  

后来，经过查找资料，有文提到对于C#是属于托管内存，现在要传递结构体数组，是属性非托管内存，必须要用Marsh指定空间，然后再传递。于是将结构体变更如下。

[csharp]  view plain copy

1. [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]  
2.      public struct Info  
3.      {  
4.          public int OrderNO;  
5.   
6.          [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]  
7.          public byte[] UniqueCode;  
8.   
9.          public float CpuPercent;                    
10.   
11.      };  

但是经过这样的改进后，运行结果依然不理想，值要么出错，要么没有被改变。这究竟是什么原因？不断的搜资料，终于看到了一篇，里面提到结构体的传递，有的可以如上面所做，但有的却不行，特别是当参数在C++中是结构体指针或者结构体数组指针时，在C#调用的地方也要用指针来对应，后面改进出如下代码。

[csharp]  view plain copy

1. [DllImport("workStation.dll")]  
2.     private static extern bool fetchInfos(IntPtr infosIntPtr);  
3.     [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]  
4.     public struct Info  
5.     {  
6.         public int OrderNO;  
7.   
8.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]  
9.         public byte[] UniqueCode;  
10.   
11.         public float CpuPercent;  
12.   
13.     };  
14.     private void buttonTest_Click(object sender, EventArgs e)  
15.     {  
16.         try  
17.         {  
18.             int workStationCount = 128;  
19.             int size = Marshal.SizeOf(typeof(Info));  
20.             IntPtr infosIntptr = Marshal.AllocHGlobal(size * workStationCount);  
21.             Info[] infos = new Info[workStationCount];  
22.             if (fetchInfos(infosIntptr))  
23.             {  
24.                 MessageBox.Show("Fail");  
25.                 return;  
26.             }  
27.             for (int inkIndex = 0; inkIndex < workStationCount; inkIndex++)  
28.             {  
29.                 IntPtr ptr = (IntPtr)((UInt32)infosIntptr + inkIndex * size);  
30.                 infos[inkIndex] = (Info)Marshal.PtrToStructure(ptr, typeof(Info));  
31.             }  
32.   
33.             Marshal.FreeHGlobal(infosIntptr);  
34.   
35.             string message = "";  
36.             foreach (Info info in infos)  
37.             {  
38.                 message += string.Format("OrderNO={0}\r\nUniqueCode={1}\r\nCpu={2}",  
39.                                        info.OrderNO,  
40.                                        Encoding.UTF8.GetString(info.UniqueCode),  
41.                                        info.CpuPercent  
42.                                        );  
43.             }  
44.             MessageBox.Show(message);  
45.   
46.         }  
47.         catch (System.Exception ex)  
48.         {  
49.             MessageBox.Show(ex.Message);  
50.         }  
51.     }  

要注意的是，这时接口已经改成IntPtr了。通过以上方式，终于把结构体数组给传进去了。不过，这里要注意一点，不同的编译器对结构体的大小会不一定，比如上面的结构体

在BCB中如果没有字节对齐的话，有时会比一般的结构体大小多出2两个字节。因为BCB默认的是2字节排序，而VC是默认1 个字节排序。要解决该问题，要么在BCB的结构体中增加字节对齐，要么在C#中多开两个字节（如果有多的话）。字节对齐代码如下。

[csharp]  view plain copy

1. #pragma pack(push,1)  
2.    struct Info  
3. {  
4.     int OrderNO;  
5.              
6.     char UniqueCode[32];  
7.   
8.     float CpuPercent;  
9. };  
10. #pragma pack(pop)  

用Marsh.AllocHGlobal为结构体指针开辟内存空间，目的就是转变化非托管内存，那么如果不用Marsh.AllocHGlobal，还有没有其他的方式呢？

其实，不论C++中的是指针还是数组，最终在内存中还是一个一个字节存储的，也就是说，最终是以一维的字节数组形式展现的，所以我们如果开一个等大小的一维数组，那是否就可以了呢？答案是可以的，下面给出了实现。

[csharp]  view plain copy

1. [DllImport("workStation.dll")]  
2.         private static extern bool fetchInfos(IntPtr infosIntPtr);  
3.         [DllImport("workStation.dll")]  
4.         private static extern bool fetchInfos(byte[] infos);  
5.         [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]  
6.         public struct Info  
7.         {  
8.             public int OrderNO;  
9.   
10.             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]  
11.             public byte[] UniqueCode;  
12.   
13.             public float CpuPercent;  
14.   
15.         };  
16.   
17.      
18.         private void buttonTest_Click(object sender, EventArgs e)  
19.         {  
20.             try  
21.             {  
22.                 int count = 128;  
23.                 int size = Marshal.SizeOf(typeof(Info));  
24.                 byte[] inkInfosBytes = new byte[count * size];                  
25.                 if (fetchInfos(inkInfosBytes))  
26.                 {  
27.                     MessageBox.Show("Fail");  
28.                     return;  
29.                 }  
30.                 Info[] infos = new Info[count];  
31.                 for (int inkIndex = 0; inkIndex < count; inkIndex++)  
32.                 {  
33.                     byte[] inkInfoBytes = new byte[size];  
34.                     Array.Copy(inkInfosBytes, inkIndex * size, inkInfoBytes, 0, size);  
35.                     infos[inkIndex] = (Info)bytesToStruct(inkInfoBytes, typeof(Info));  
36.                 }  
37.   
38.                 string message = "";  
39.                 foreach (Info info in infos)  
40.                 {  
41.                     message += string.Format("OrderNO={0}\r\nUniqueCode={1}\r\nCpu={2}",  
42.                                            info.OrderNO,  
43.                                            Encoding.UTF8.GetString(info.UniqueCode),  
44.                                            info.CpuPercent  
45.                                            );  
46.                 }  
47.                 MessageBox.Show(message);  
48.   
49.             }  
50.             catch (System.Exception ex)  
51.             {  
52.                 MessageBox.Show(ex.Message);  
53.             }  
54.         }  
55.  
56.         #region bytesToStruct  
57.         /// <summary>  
58.         /// Byte array to struct or classs.  
59.         /// </summary>  
60.         /// <param name=”bytes”>Byte array</param>  
61.         /// <param name=”type”>Struct type or class type.  
62.         /// Egg:class Human{...};  
63.         /// Human human=new Human();  
64.         /// Type type=human.GetType();</param>  
65.         /// <returns>Destination struct or class.</returns>  
66.         public static object bytesToStruct(byte[] bytes, Type type)  
67.         {  
68.   
69.             int size = Marshal.SizeOf(type);//Get size of the struct or class.            
70.             if (bytes.Length < size)  
71.             {  
72.                 return null;  
73.             }  
74.             IntPtr structPtr = Marshal.AllocHGlobal(size);//Allocate memory space of the struct or class.   
75.             Marshal.Copy(bytes, 0, structPtr, size);//Copy byte array to the memory space.  
76.             object obj = Marshal.PtrToStructure(structPtr, type);//Convert memory space to destination struct or class.           
77.             Marshal.FreeHGlobal(structPtr);//Release memory space.      
78.             return obj;  
79.         }  
80.         #endregion  

对于实在想不到要怎么传数据的时候，可以考虑byte数组来传(即便是整型也可以，只要是开辟4字节(在32位下))，只要开的长度对应的上，在拿到数据后，要按类型规则转换成所要的数据，一般都能达到目的。

转载请注明出处 http://blog.csdn.net/xxdddail/article/details/11781003