Marshal C ++ int array su C #

Mi piacerebbe schierare una schiera di Ints da C ++ a C #. Ho una dll C ++ non gestita che contiene:

DLL_EXPORT int* fnwrapper_intarr() { int* test = new int[3]; test[0] = 1; test[1] = 2; test[2] = 3; return test; } 

con dichiarazione nell’intestazione extern "C" DLL_EXPORT int* fnwrapper_intarr();

Sto quindi usando Pinvoke per metterlo in marcia in C #:

 [DllImport("wrapper_demo_d.dll")] [return: MarshalAs(UnmanagedType.SafeArray)] public static extern int[] fnwrapper_intarr(); 

E io uso la funzione in questo modo:

 int[] test = fnwrapper_intarr(); 

Tuttavia, durante l’esecuzione del programma viene visualizzato il seguente errore: SafeArray cannot be marshaled to this array type because it has either nonzero lower bounds or more than one dimension.

Quale tipo di array dovrei usare? O c’è un modo bettery di schierare array o vettori di interi?

 [DllImport ( "wrapper_demo_d.dll")]
 public static extern IntPtr fnwrapper_intarr ();

 IntPtr ptr = fnwrapper_intarr ();
 int [] result = new int [3];
 Marshal.Copy (ptr, result, 0, 3);

È necessario anche scrivere la funzione di rilascio nella Dll non gestita, che elimina il puntatore creato da fnwrapper_intarr. Questa funzione deve accettare IntPtr come parametro.

 DLL_EXPORT void fnwrapper_release (int * pArray)
 {
     delete [] pArray;
 }

 [DllImport ( "wrapper_demo_d.dll")]
 public static extern void fnwrapper_release (IntPtr ptr);

 IntPtr ptr = fnwrapper_intarr ();
 ...
 fnwrapper_release (PTR);