Instruction fixe avec tableau dentelé

Question

J'ai un tableau irrégulier que je dois passer à la méthode externe.

[DllImport(...)] 
private static extern int NativeMethod(IntPtr[] ptrArray); 

... 

fixed (ulong* ptr = array[0]) 
{ 
    for (int i = 0; i < array.Length; i++) 
    { 
     fixed (ulong* p = &array[i][0]) 
     { 
      ptrArray[i] = new IntPtr(p); 
     } 
    } 

    NativeMethod(ptrArray); 
} 

Le problème est que ptr est inutilisé et est retiré en raison de la compilation. La déclaration fixe selon elle est supprimée aussi. Donc, le tableau est déplacé par GC de cette façon que les éléments ptrArray deviennent invalides. Quel est le meilleur moyen de faire passer des tableaux dentelés sous la forme de tableaux unidimensionnels de pointeurs vers des méthodes natives?

Mise à jour:

Voici le code C++ pour NativeMethod:

NativeClass::NativeMethod(const int* array) 

Answer 1

Votre problème est le fait que vous avez besoin tableau à être fixé puisque c'est celui que vous utilisez. Vous pouvez épingler le tableau afin que GC ne recueille pas:

GCHandle h = GCHandle.Alloc(array, GCHandleType.Pinned); 

MISE À JOUR

Comme vous l'avez souligné à juste titre, chaque tableau dans le tableau besoins épinglant aussi bien.

Answer 2

J'ai été en mesure de passer une matrice dentelée C# à C++ via une méthode Pinvoke externe sans utiliser de code C# dangereux comme dans l'exemple de code ci-dessous. Mais j'ai toujours mes préoccupations concernant le GC en mode non-débogage provoquant des effets secondaires indésirables. Voici le morceau de code de test (qui fonctionne en mode débogage):

[Test, Ignore] 
public void Test_JaggedArrayPInvoke() 
{ 
    var jaggedArray = new int[3][]; 
    jaggedArray[0] = new int[1] { 9 }; 
    jaggedArray[1] = new int[4] { 1, 2, 3, 8 }; 
    jaggedArray[2] = new int[2] { 1, 2 }; 

    //GCHandle mainHandle = GCHandle.Alloc(jaggedArray, GCHandleType.Pinned); //This does not work 

    var pinnedHandles = new GCHandle[3];      
    var jaggedArrayPtrs = new IntPtr[3]; 
    for (int i = 0; i < 3; i++) 
    { 
     pinnedHandles[i] = GCHandle.Alloc(jaggedArray[i], GCHandleType.Pinned); 
     jaggedArrayPtrs[i] = pinnedHandles[i].AddrOfPinnedObject(); 
    } 

    var result = JaggedArrayPInvoke_TEST(jaggedArrayPtrs); 

    Console.WriteLine(result); //returns 8 as it should. 

    //mainHandle.Free(); 
    for (int i = 0; i < 3; i++) 
    { 
     pinnedHandles[i].Free(); 
    } 
} 

//The C++ test method: 

extern "C" __declspec(dllexport) int __stdcall JaggedArrayPInvoke_TEST(int** jaggedArray); 
__declspec(dllexport) int __stdcall JaggedArrayPInvoke_TEST(int** jaggedArray) 
{ 
    return jaggedArray[1][3]; 
} 

Si je devais décommenter la partie mainHandle, je reçois une exception d'argument "objet contient des données non-primitive ou non blittable". Alors est-il possible d'épingler le jaggedArray et est-ce vraiment nécessaire? (Je me souviens vaguement que GC en mode release peut se souvenir de la mémoire déjà dans les méthodes s'il n'est plus utilisé.) Je pense que transformer le jaggedArray en une variable de champ de classe le rendrait sûr du point de vue du GC.