The ultimate solution for C to call C++DLL to pass structure arrays
- 2021-11-29 08:15:54
- OfStack
The ultimate solution for C # calling C++DLL to pass structure arrays
In the project development, to call DLL encapsulated by C + +, the common type C # 1 generally corresponds, as long as DllImport is passed in to introduce functions from DLL. But when you pass a structure, an array of structures, or a pointer to a structure, you will find that there is no type on C # to correspond to. 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 want to pass parameters in after defining a structure, we will throw an exception, or pass in the structure, but the return value is not what we want. After debugging and tracing, we find 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);
}
}
Later, after looking up the data, it was mentioned that C # belongs to managed memory. Now, to pass the structure array, it is an attribute unmanaged memory, and it is necessary to specify the space with Marsh, and then pass it. The structure is then changed 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;
};
However, after such improvement, the running result is still not ideal, and the value either goes wrong or has not been changed. What is the reason for this? Constantly searching for data, finally saw a article, which mentioned the transfer of structure, some can be done as above, but some can't, especially when the parameters are structure pointer or structure array pointer in C + +, the place called in C # should also use pointer to correspond, and the following code is improved.
[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);
}
}
Note that the interface has been changed to IntPtr. In the above way, the structure array is finally passed in. However, one point to note here is that different compilers will vary the size of structures, such as the above structure
If there is no byte alignment in BCB, there are sometimes 2 bytes more than the 1-like structure size. Because BCB defaults to a 2-byte sort, while VC defaults to a 1-byte sort. To solve this problem, either add byte alignment to the structure of BCB or open two more bytes (if any) 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)
Use Marsh. AllocHGlobal to open up memory space for structure pointer, the purpose is to change unmanaged memory, so if you don't use Marsh. AllocHGlobal, is there any other way?
In fact, no matter whether it is a pointer or an array in C + +, it is finally stored in memory or a 1-byte, that is to say, it is finally displayed in the form of a 1-dimensional byte array, so if we open a 1-dimensional array of the same size, is it OK? The answer is yes, and 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
When you really can't think of how to transmit data, you can consider byte array to transmit it (even if it is an integer, as long as it opens up 4 bytes (under 32 bits)), as long as the length of it corresponds to it, after getting the data, it should be converted into the required data according to the type rules, and the purpose can be achieved.
Thank you for reading, hope to help everyone, thank you for your support to this site!