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  
posted @ 2016-04-05 16:41  C#winform软件设计  阅读(1741)  评论(0)  编辑  收藏  举报