C#

_Erik_ wrote:

Yes, that's right, but when you make a P/Invoke call, the CLR automatically pins the references passed to the unmanaged function into the managed heap, so the references will not move until the call is finished so, if you use references (such as byte[]), there is no need to manually pin them.

_Erik_ wrote:

Try importing the unmanaged function as I told you before, I mean, use byte[][] and not byte** as the type for the first parameter. Belive me, this is the easiest way, it's worth to try. We can try the tricky version later if this does not work.

private T[] _items;

public static T[][] ArrayToArray<T>(T[] element)
{
    return new T[1][]{ element };
}

Chesnokov Yuriy wrote:

byte[] arrays can be of variable length. it will not be possible to create byte[][] from them.

Chesnokov Yuriy wrote:

but there will be no trouble if you alter the bytes of the array in unmanaged side.
they are passed as pointers, thus unmanaged application can modify them.

List<MyObject> myObjects;  //MyObject contains byte[] field accessed by Data

byte[][] data = new byte[myObjects.Count][];
for (i = 0; i < myObjects.Count; i++)
    data[i][] = myObjects[i].Data;

//thus data now contains array of pointers
//pass it to unmanaged function taking byte** argument
//declared with byte[][] signature in DllImport

void function(byte** data, int N)
{
     // are those pointers allways map to valid address?
     byte* pRow = data[0];
     pRow = data[1];
     pRow = data[2];
     // ....
     pRow = data[N - 1];   
}

"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;