Marshalling Complex structures between C#/C++

c#, c++, marshalling

Solution

Okay, I have a working sample. I'm posting this as another answer because it's a very different approach.

So, on the C++ side, I've got this header file:

struct Struct1
{
  int d1[10];
  int d2[10];
};

extern "C" __declspec(dllexport) void __stdcall 
  TestApi2(int* pLength, Struct1 **pStructures);

And the following code:

__declspec(dllexport) void __stdcall 
  TestApi2(int* pLength, Struct1 **pStructures)
{
  int len = 10;

  *pLength = len;
  *pStructures = (Struct1*)LocalAlloc(0, len * sizeof(Struct1));

  Struct1 *pCur = *pStructures;

  for (int i = 0; i < len; i++)
  {
    for (int idx = 0; idx < 10; ++idx)
    {
      pCur->d1[idx] = i + idx;
      pCur->d2[idx] = i + idx;
    }

    pCur ++;
  }
}

Now, the important bit is `LocalAlloc`. That's actually the place where I've had all the issues, since I allocated the memory wrong. `LocalAlloc` is the method .NET calls when it does `Marshal.AllocHGlobal`, which is very handy, since that means we can use the memory in the caller and dispose of it as needed.

Now, this method allows you to return an arbitrary length array of structures. The same approach can be used to eg. return a structure of an array of structures, you're just going deeper. The key is the `LocalAlloc` - that's memory you can easily access using the `Marshal` class, and it's memory that isn't thrown away.

The reason you have to also return the length of the array is because there's no way to know how much data you're "returning" otherwise. This is a common "problem" in unmanaged code, and if you've ever done any P/Invoking, you know everything about this.

And now, the C# side. I've tried hard to do this in a nice way, but the problem is that arrays of structures simply aren't blittable, which means you can't simply use `MarshalAs(UnmanagedType.LPArray, ...)`. So, we have to go the `IntPtr` way.

The definitions look like this:

[StructLayout(LayoutKind.Sequential)]
public class Struct1
{
  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
  public int[] d1;

  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
  public int[] d2;
}        

[DllImport(@"Win32Project.dll", CallingConvention = CallingConvention.StdCall)]
static extern void TestApi2(out int length, out IntPtr structs);

Basically, we get a pointer to the length of the "array", and the pointer to the pointer to the first element of the array. That's all we need to read the data.

The code follows:

int length;
IntPtr pStructs;

TestApi2(out length, out pStructs);

// Prepare the C#-side array to copy the data to
Struct1[] structs = new Struct1[length];

IntPtr current = pStructs;
for (int i = 0; i < length; i++)
{
  // Create a new struct and copy the unmanaged one to it
  structs[i] = new Struct1();
  Marshal.PtrToStructure(current, structs[i]);

  // Clean-up
  Marshal.DestroyStructure(current, typeof(Struct1));

  // And move to the next structure in the array
  current = (IntPtr)((long)current + Marshal.SizeOf(structs[i]));
}

// And finally, dispose of the whole block of unmanaged memory.
Marshal.FreeHGlobal(pStructs);

The only thing that changes if you want to really return a structure of an array of structures is that the method parameters move into the "wrapping" structure. The handy thing is that .NET can automatically handle the marshalling of the wrapper, the less-handy thing is that it can't handle the inner array, so you again have to use length + IntPtr to manage this manually.

Problem

Original source