Marshaling structs with strings and arrays from managed to unmanaged code

I have a simple C# data structure with a string, an int and a vector of ints:

class MyManagedClass
{
    public string m_Str;
    int m_Int;
    int[] m_IntArray;
}

The equivalent in C++ is:

struct myUnmanagedStruct
{
    char* m_Str;
    UINT m_Int;
    UINT* m_IntArray;
}

I have an unmanaged function that creates an array of myUnmanagedStruct structs. What is the best way to write a managed wrapper that correctly marshals the data such that what is created on the unmanaged side is correctly passed back to the managed side? (i.e. I want to make an array of MyManagedClass objects from an array of MyUnmanagedStructs)

Note:

a) A string is created in the unmanaged struct

b) A vector of ints is created in the unmanaged struct

My best attempt so far is:

On the managed side:

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack=1)]
    public class MyManagedClass
    {
        public MyManagedClass()
        {
            m_IntArray = new int[4];
        }

        public String m_Str;
        public int m_Int;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public int[] m_IntArray;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct UnsafeLCEArray
    {
        public int m_Int;
        public IntPtr m_CharBuf;
        public IntPtr m_IntBuf;
    }

    public unsafe class LibWrap
    {
        // Declares managed prototypes for the unmanaged function.
        [DllImport("mydll.dll", EntryPoint = "GetUnmanagedStructs")]
        public static extern voidGetUnmanagedStructs(out int size, out IntPtr outArray);
    }

On the unmanaged side:

typedef struct _MyUnmanagedStruct
{
   char* m_Str;
   UINT m_Int;
   UINT* m_IntArray;
} MyUnmanagedStruct;

typedef struct _UNSAFELCEARRAY
{
    char* strBuf;
    UINT intBuf; 
    UINT* intArrayBuf;
} UNSAFELCEARRAY;

extern "C" __declspec(dllexport) void GetUnmanagedStructs( int* pSize, UNSAFELCEARRAY** ppStruct )
{
    const int cArraySize = 5;
    *pSize = cArraySize;
    int numBytes = cArraySize * sizeof( MyUnmanagedStruct);
    *ppStruct = (UNSAFELCEARRAY*)CoTaskMemAlloc(numBytes);

    UNSAFELCEARRAY* pCurStruct = *ppStruct;
    char* typenamebuffer;
    char* numBuffer;
    int var = 999;
    for( int i = 0; i < cArraySize; i++, pCurStruct++ )
    {
       pCurStruct->intBuf = i+1;

       typenamebuffer = (char*)CoTaskMemAlloc( 8 );
       memcpy_s(typenamebuffer,    8, "bufABCD", 8);
       pCurStruct->strBuf = typenamebuffer;

       numBuffer = (char*)CoTaskMemAlloc( 16 );
       ++var;
       memcpy_s(numBuffer,    4, &var, 4);
       ++var;
       memcpy_s(numBuffer+4,  4, &var, 4);
       ++var;
       memcpy_s(numBuffer+8,  4, &var, 4);
       ++var;
       memcpy_s(numBuffer+12, 4, &var, 4);
       pCurStruct->intArrayBuf = (UINT*)numBuffer;
    }
 }

Everything works if I remove the vector of ints from the managed and unmanaged objects, but with the code above the array of ints is uninitialized on return. I use the function below to generate MyManagedClasses from MyUnmanagedStructs

        int size;
        IntPtr outArray;
        LibWrap.GetUnman开发者_C百科agedStructs(out size, out outArray);

        manArray = new MyManagedClass[size];
        IntPtr current = outArray;
        for (int i = 0; i < size; i++)
        {
            manArray[i] = new MyManagedClass();
            Marshal.PtrToStructure(current, manArray[i]);

            Marshal.DestroyStructure(current, typeof(sb_LCE));
            int numBytes = Marshal.SizeOf(manArray[i]);
            current = (IntPtr)((long)current + numBytes);
        }
        Marshal.FreeCoTaskMem(outArray);

Forgive the lengthy explanation and the fact the unmanaged strut is being filled with dummy values. This is just for illustration.