C#

John Simmons / outlaw programmer wrote:

Of course, you're assuming I wanted to avoid being rude, or that I wasn't matter-of-factly posing a reasonable question

void function(byte** data, unsigned int N, unsigned int M)
{
for (int i = 0; i < N; i++)
{
   for (int j = 0; j < M; j++)
       printf("%c ", data[i][j]);
   printf("\n"); 
}
}

byte[][] arr = lst.ToArray<byte[]>();

Chesnokov Yuriy wrote:

It is not possible to pass managed byte[][] to unmanaged byte**.

Chesnokov Yuriy wrote:

Even if it was possible managed memory is not fixed.

Chesnokov Yuriy wrote:

I have List and I need to pass it to byte**.

Chesnokov Yuriy wrote:

byte[][] conversion is out of scope as arrays may be of different size.

Chesnokov Yuriy wrote:

It needs to allocate with static alloc array to hold pinned pointers. Then to pin them.

_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 ....