无法编组“参数＃”：内部限制：结构太复杂或太大

Question

I have a dll developed in C++. I need to use it with C#.

[StructLayout(LayoutKind.Sequential, Size = 205004, Pack = 1)]
    private struct MyList
    {
        public UInt32 count;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 100)]
        public myStruct[] info;
    };

"myStruct" has of size 2050. I am calling the dll method as

[DllImport("dllName.dll" CallingConvention = CallingConvention.Cdecl)]
private static extern UInt32 GetMyList(out MyList list);

I get an error when I call the dll method. "Cannot marshal 'parameter #1': Internal limitation: structure is too complex or too large."

Do any one have a solution by not changing the C++ dll parts?

Answer 1

As the error says, the structure is too large to be marshalled that way. So you will have to find another approach.

It would make more sense, in my view, to return the structs one at a time. That will avoid you needing to hard code an upper limit of there being no more than 100 structs in the list.

So I would write it like this:

C++

int GetListCount()
{
    return count;
}

int GetListItem(int index, myStruct* item)
{
    if (index < 0)
        return -1;
    if (index >= count)
        return -1;
    *item = items[index];
    return 0;
}

C#

[DllImport("dllName.dll" CallingConvention = CallingConvention.Cdecl)]
private static extern int GetListCount();

[DllImport("dllName.dll" CallingConvention = CallingConvention.Cdecl)]
private static extern int GetListItem(int index, out myStruct item);

....

int count = GetListCount();
myStruct[] items = new myStruct[count];
for (int index = 0; index < count; index++)
{
    int retval = GetListItem(out items[index]);
    if (retval != 0)
        // handle error
}

If you cannot change the DLL then you are faced with performing the marshalling by hand. It would go like this:

[DllImport("dllName.dll" CallingConvention = CallingConvention.Cdecl)]
private static extern UInt32 GetMyList(IntPtr listPtr);

....

IntPtr listPtr = Marshal.AllocHGlobal(205004); // Argh! Magic constant alert
try
{
    int retval = GetMyList(listPtr);
    // presumably you are expected to do something with retval
    int count = Marshal.ReadInt32(listPtr);
    myStruct[] items = new myStruct[count];
    for (int index = 0; index < count; index++)
    {
        IntPtr itemPtr = listPtr + 4 + index*2050; // More magic constants!
        items[index] = (myStruct)Marshal.PtrToStructure(itemPtr, typeof(myStruct));
    } 
}
finally
{
    Marshal.FreeHGlobal(listPtr);
}

You might prefer to use Marshal.SizeOf rather than the magic constants.