Question

I wrote in C a struct like that

struct IMAGE {
    unsigned int    x, y;
    unsigned char   **data;
};

Could anybody please tell me how to marshall this struct to use in C#?

my solution does not work.

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class IMAGE
{
            public UInt32 x;
            public UInt32 y;

            public byte[][] data;
};

Answer 1

Managed arrays are different than pointers. A managed array requires the size of the array, and if you’re trying to marshal a struct, it requires a fixed size to marshal directly.

You can use the SizeConst parameter of the MarshalAs attribute to set the size of data when it gets marshaled.

But I’m guessing that x and y are the dimensions of the image and that the size of data depends on those variables. The best solution here is to marshal it over as an IntPtr and access the data when you need it:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class IMAGE
{
    public UInt32 x;
    public UInt32 y;

    private IntPtr data;

    public byte[][] Data
    {
        get
        {
            byte[][] newData = new byte[y][];

            for(int i = 0; i < y; i++)
            {
                newData[i] = new byte[x];
                Marshal.Copy(new IntPtr(data.ToInt64() + (i * x)), newData[i], 0, x);
            }

            return newData;
        }

        set
        {
            for (int i = 0; i < value.Length; i++)
            {
                Marshal.Copy(value[i], 0, new IntPtr(data.ToInt64() + (i * x)), value[i].Length);
            }
        }
    }
}

If you are allowed to use unsafe code, you can change the IntPtr to a byte** and work with it directly.

With the setter, you’ll probably want to verify the dimensions of the value before you blindly write to unmanaged memory.