Detailed explanation of the solution to C# calling C++DLL to pass structure array-C#.Net Tutorial-php.cn

This article mainly introduces relevant information on the ultimate solution for C# to call C++DLL to pass a structure array. Friends in need can refer to

C# to call C++DLL to pass a structure. The ultimate solution for body arrays

When developing a project, it is necessary to call the C++ encapsulated DLL. Common types generally correspond to C#. Just use DllImport to introduce the function# from the DLL. ## will do. But when a structure, structure array, or structure pointer is passed, you will find that there is no corresponding type in C#. What to do at this time? The first reaction is that C# also defines the structure and then passes it on as a parameter. However, when we define a structure and want to pass parameters into it, an exception will be thrown, or the structure will be passed in, but the return value is not what we want. After Debugging tracking, we found that, Those values have not changed at all, the code is as follows.

[DllImport("workStation.dll")] 
    private static extern bool fetchInfos(Info[] infos); 
    public struct Info 
    { 
      public int OrderNO; 
 
      public byte[] UniqueCode; 
 
      public float CpuPercent;          
 
    }; 
    private void buttonTest_Click(object sender, EventArgs e) 
    { 
      try 
      { 
      Info[] infos=new Info[128]; 
        if (fetchInfos(infos)) 
        { 
          MessageBox.Show("Fail"); 
        } 
      else 
      { 
          string message = ""; 
          foreach (Info info in infos) 
          { 
            message += string.Format("OrderNO={0}\r\nUniqueCode={1}\r\nCpu={2}", 
                       info.OrderNO, 
                       Encoding.UTF8.GetString(info.UniqueCode), 
                       info.CpuPercent 
                       ); 
          } 
          MessageBox.Show(message); 
      } 
      } 
      catch (System.Exception ex) 
      { 
        MessageBox.Show(ex.Message); 
      } 
    }

Copy after login

Later, after searching for information, an article mentioned that C# is managed memory. Now we need to pass the structure array, which is

propertyunmanaged memory, and we must use Marsh to specify the space. Then pass it on. So change the structure as follows.

StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
   public struct Info 
   { 
     public int OrderNO; 
 
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] 
     public byte[] UniqueCode; 
 
     public float CpuPercent;          
 
   };

Copy after login

But after such improvements, the running results are still not ideal, and the values are either wrong or not changed. What is the reason for this? After constantly searching for information, I finally found an article, which mentioned the transfer of structures. Some can be done as above, but some cannot, especially when the parameter is a structure pointer or a structure array pointer in C++. , pointers should also be used to correspond to C# calls, and the following code will be improved later.

[DllImport("workStation.dll")] 
  private static extern bool fetchInfos(IntPtr infosIntPtr); 
  [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
  public struct Info 
  { 
    public int OrderNO; 
 
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] 
    public byte[] UniqueCode; 
 
    public float CpuPercent; 
 
  }; 
  private void buttonTest_Click(object sender, EventArgs e) 
  { 
    try 
    { 
      int workStationCount = 128; 
      int size = Marshal.SizeOf(typeof(Info)); 
      IntPtr infosIntptr = Marshal.AllocHGlobal(size * workStationCount); 
      Info[] infos = new Info[workStationCount]; 
      if (fetchInfos(infosIntptr)) 
      { 
        MessageBox.Show("Fail"); 
        return; 
      } 
      for (int inkIndex = 0; inkIndex < workStationCount; inkIndex++) 
      { 
        IntPtr ptr = (IntPtr)((UInt32)infosIntptr + inkIndex * size); 
        infos[inkIndex] = (Info)Marshal.PtrToStructure(ptr, typeof(Info)); 
      } 
 
      Marshal.FreeHGlobal(infosIntptr); 
 
      string message = ""; 
      foreach (Info info in infos) 
      { 
        message += string.Format("OrderNO={0}\r\nUniqueCode={1}\r\nCpu={2}", 
                    info.OrderNO, 
                    Encoding.UTF8.GetString(info.UniqueCode), 
                    info.CpuPercent 
                    ); 
      } 
      MessageBox.Show(message); 
 
    } 
    catch (System.Exception ex) 
    { 
      MessageBox.Show(ex.Message); 
    } 
  }

Copy after login

It should be noted that at this time

Interface has been changed to IntPtr. Through the above method, the structure array is finally passed in. However, one thing to note here is that different compilers may not be sure about the size of the structure. For example, if the above structure

is not byte aligned in BCB, it will sometimes be larger than the normal structure. The body size is 2 bytes more. Because BCB defaults to 2-byte sorting, and VC defaults to 1-byte sorting. To solve this problem, either add byte alignment to the BCB structure, or open two more bytes (if there are more) in C#. The byte alignment code is as follows.

#pragma pack(push,1) 
  struct Info 
{ 
  int OrderNO; 
       
  char UniqueCode[32]; 
 
  float CpuPercent; 
}; 
#pragma pack(pop)

Copy after login

Use Marsh.AllocHGlobal to open up memory space for structure pointers. The purpose is to convert unmanaged memory. So if Marsh.AllocHGlobal is not used, is there any other way?

In fact, no matter whether it is a pointer or an array in C++, it is ultimately stored in memory one by one. That is to say, it is ultimately displayed in the form of a one-dimensional byte array, so If we open a

one-dimensional array of equal size, is that okay? The answer is yes, the implementation is given below.

[DllImport("workStation.dll")] 
    private static extern bool fetchInfos(IntPtr infosIntPtr); 
    [DllImport("workStation.dll")] 
    private static extern bool fetchInfos(byte[] infos); 
    [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
    public struct Info 
    { 
      public int OrderNO; 
 
      [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] 
      public byte[] UniqueCode; 
 
      public float CpuPercent; 
 
    }; 
 
   
    private void buttonTest_Click(object sender, EventArgs e) 
    { 
      try 
      { 
        int count = 128; 
        int size = Marshal.SizeOf(typeof(Info)); 
        byte[] inkInfosBytes = new byte[count * size];         
        if (fetchInfos(inkInfosBytes)) 
        { 
          MessageBox.Show("Fail"); 
          return; 
        } 
        Info[] infos = new Info[count]; 
        for (int inkIndex = 0; inkIndex < count; inkIndex++) 
        { 
          byte[] inkInfoBytes = new byte[size]; 
          Array.Copy(inkInfosBytes, inkIndex * size, inkInfoBytes, 0, size); 
          infos[inkIndex] = (Info)bytesToStruct(inkInfoBytes, typeof(Info)); 
        } 
 
        string message = ""; 
        foreach (Info info in infos) 
        { 
          message += string.Format("OrderNO={0}\r\nUniqueCode={1}\r\nCpu={2}", 
                      info.OrderNO, 
                      Encoding.UTF8.GetString(info.UniqueCode), 
                      info.CpuPercent 
                      ); 
        } 
        MessageBox.Show(message); 
 
      } 
      catch (System.Exception ex) 
      { 
        MessageBox.Show(ex.Message); 
      } 
    } 
 
    #region bytesToStruct 
    /// <summary> 
    /// Byte array to struct or classs. 
    /// </summary> 
    /// <param name=”bytes”>Byte array</param> 
    /// <param name=”type”>Struct type or class type. 
    /// Egg:class Human{...}; 
    /// Human human=new Human(); 
    /// Type type=human.GetType();</param> 
    /// <returns>Destination struct or class.</returns> 
    public static object bytesToStruct(byte[] bytes, Type type) 
    { 
 
      int size = Marshal.SizeOf(type);//Get size of the struct or class.      
      if (bytes.Length < size) 
      { 
        return null; 
      } 
      IntPtr structPtr = Marshal.AllocHGlobal(size);//Allocate memory space of the struct or class.  
      Marshal.Copy(bytes, 0, structPtr, size);//Copy byte array to the memory space. 
      object obj = Marshal.PtrToStructure(structPtr, type);//Convert memory space to destination struct or class.      
      Marshal.FreeHGlobal(structPtr);//Release memory space.   
      return obj; 
    } 
    #endregion

Copy after login

When you really can’t think of how to transmit data, you can consider transmitting it as a byte array (even an integer is acceptable, as long as it is 4 bytes (under 32 bits)), as long as the length corresponds to After getting the data, it needs to be converted into the required data according to the type rules, which can generally achieve the purpose.

The above is the detailed content of Detailed explanation of the solution to C# calling C++DLL to pass structure array. For more information, please follow other related articles on the PHP Chinese website!