C#

"Cannot marshal 'parameter #1': There is no marshaling support for nested arrays." System.Exception System.Runtime.InteropServices.MarshalDirectiveException<br />

unsafe static void Print()
{
        Random random = new Random();
                        
        List<int[]> list = new List<int[]>();
        int nRows = random.Next(1, 25);
        for (int i = 0; i < nRows; i++)
        {
                int nCols = random.Next(1, 25);
                int[] row = new int[nCols];
                row[0] = nCols;
                list.Add(row);
        }

        int[][] data = new int[list.Count][];
        for (int i = 0; i < list.Count; i++)
                data[i] = list[i];
                        
        print(data, nRows);
}

[DllImport("native.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
static extern unsafe int print(int[][] data, int nRows);

NATIVE_API void print(int** data, int nRows)
{
        _tprintf(_T("data** size: %d\n"), sizeof(data));
        _tprintf(_T(" data* size: %d\n"), sizeof(data[0]));
	for (int i = 0; i < nRows; i++) {
                int nCols = data[i][0]; 
                for (int j = 0; j < nCols; j++)
                        _tprintf(_T("%3d "), data[i][j]);
                _tprintf(_T("\n"));
        }
}

Chesnokov Yuriy wrote:

I'm going to change my votes ....

public static IntPtr[] Allocate(List<byte[]> byteArrayList)
{
    // maintain an array of allocated unmanaged pointers
    IntPtr[] allocatedPointers = new IntPtr[byteArrayList.Count];
    int counter = 0;
    foreach (byte[] byteArray in byteArrayList)
    {
        // allocate data to unmanaged pointer (pointer to byte array)
        IntPtr pointerToByteArray = Marshal.AllocHGlobal(byteArray.Length);
        // copy data
        Marshal.Copy(byteArray, 0, pointerToByteArray, byteArray.Length);
        // copy unmanaged pointer to array
        allocatedPointers[counter] = pointerToByteArray;
        counter++;
    }
    return allocatedPointers;
}

public static void Free(IntPtr[] allocatedPointers)
{
    foreach (IntPtr allocatedPointer in allocatedPointers)
        Marshal.FreeHGlobal(allocatedPointer);
}

IntPtr[] data = new IntPtr[list.Count];
for (int i = 0; i < list.Count; i++)
{
        row = list[i];
        GCHandle handle = GCHandle.Alloc(row, GCHandleType.Pinned);
        data[i] = handle.AddrOfPinnedObject();
}

print(data, nRows);

for (int i = 0; i < list.Count; i++)
{
        GCHandle handle = GCHandle.FromIntPtr(data[i]);
        handle.Free();
}

Managed Debugging Assistant 'FatalExecutionEngineError' has detected a problem in 'C:\projs\native\Debug\NativeTest.exe'.
Additional Information: The runtime has encountered a fatal error. The address of the error was at 0x655229e9, on thread 0xebc. The error code is 0xc0000005. This error may be a bug in the CLR or in the unsafe or non-verifiable portions of user code. Common sources of this bug include user marshaling errors for COM-interop or PInvoke, which may corrupt the stack.

for (int i = list.Count - 1; i >= 0; i--)
{        
    GCHandle handle = GCHandle.FromIntPtr(data[i]);
    handle.Free();
}

public class ByteMatrix
{
    byte[,] _matrix;
    int _n;
    int _m;

    public ByteMatrix(int n, int m)
    {
        _matrix = new byte[n, m];
        _n = n;
        _m = m;
    }

    // Methods, indexers and properties to add, remove, etc, as needed

    // Import the unmanaged function here, as private
    [DllImport ... whatever]
    private static extern int unmanagedFunction(byte[,] array, int n, int m);

    // Wrap the unmanaged function whithin this class
    public int CallUnmanaged() // Here a good name, of course
    {
        return unmanagedFunction(_matrix, _n, _m);
    }
}

public class ByteMatrix
{
    byte[,] _matrix;
    int _n;
    int _m;
    public ByteMatrix(int n, int m)
    {
        _matrix = new byte[n, m];
        _n = n;
        _m = m;
    }
    // Methods, indexers and properties to add, remove, etc, as needed
    // Import the unmanaged function here, as private
    [DllImport ... whatever]
    private static extern int unmanagedFunction(IntPtr array, int n, int m);
    // Wrap the unmanaged function whithin this class
    public int CallUnmanaged() // Here a good name, of course
    {
        // Pin the _matrix in managed heap first
        GCHandle handle = GCHandle.Alloc(_matrix, GCHandleType.Pinned);
        int ret = unmanagedFunction(handle.AddrOfPinnedObject(), _n, _m);
        // Release the handle
        handle.Free();

        return ret;
    }

int CallUnmanagedMethod(List<byte[]> lst)
{
    GCHandle[] handleArray = new GCHandle[lst.Count];

    for (int i=0; i<lst.Count; i++)
        handleArray[i] = GCHandle.Alloc(lst[i], GCHandleType.Pinned);

    IntPtr[] pointers = (from GCHandle handle in handleArray select
                            handle.GetAddrOfPinnedObject()).ToArray();

    // Call the unmananged method here
    int ret = unmanagedMethod(pointers, ... // rest of the parameters

    // Release the handles
    foreach (GCHandle handle in handleArray)
        handle.Free();

    return ret;
}

_Erik_ wrote:

I don't have time to make tests, but I am trying to help you. However, I won't be able to do so if you discard my suggestions before giving them a try. I

GCHandle handle2 = handle1;