C#

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;

try { foo; } catch {}