Passer une structure contenant un tableau int de taille inconnue de C# à c et retour

Question

Je commence à avoir des problèmes avec ce problème. J'ai cherché et recherché de l'aide, et tout ce que j'ai essayé ne semble pas fonctionner. Je fais évidemment quelque chose de mal.

Quoi qu'il en soit - i ont une structure C# définie comme:

public struct TestStruct 
[StructLayout(LayoutKind.Sequential)] 
{ 
    public int num; 
    public IntPtr intArrayPtr; 
} 

et dans le corps principal de mon code C# j'ai:

public class Testing 
{ 
    [DllImport("testing.dll")] 
    static extern void Dll_TestArray(out IntPtr intArrayPtr); 

    public GetArray() 
    { 
     IntPtr structPtr = IntPtr.Zero; 
     TestStruct testStruct; 
     structPtr = Marshal.AllocHGlobal(Marshal.SizeOf(testStruct)); 
     Marshal.StructureToPtr(testStruct, structPtr, false); 

     Dll_TestArray(structPtr); 

     testStruct = (TestStruct) Marshal.PtrToStructure(structPtr, typeof(TestStruct)); 
    } 
} 

Alors maintenant, pour le C++ partie. A partir de la structure:

struct TestStruct 
{ 
    public: 
    int num; 
    int* intArray; 
} 

et maintenant les fonctions:

extern "C" __declspec(dllexport) void Dll_TestArray(TestStruct *&testStruct) 
{ 
    int num = 15; 
    testStruct->num = num; 
    testStruct->intArray = new int[num]; 

    for (int i = 0; i < num; i++) 
    testStruct->intArray[i] = i+1; 
} 

Alors - Le problème que je vais avoir, est que lorsque je reçois la structure arrière en C#, ma structure est pas comment devrait être. Je peux voir que le champ num a été rempli correctement: il montre 15. Cependant, c'est le IntPtr qui est toujours mis à zéro. La création de tableau effectuée en C++ n'a pas été réalisée en C#.

Si j'essaie de revenir en arrière, et revenir dans la fonction dll, je peux voir que le tableau a été créé ok et conserve toujours l'information. Ainsi, le C# intptr dans la structure n'est pas défini sur le pointeur créé en C++ (si cela a du sens).

Donc, ma question est vraiment - comment fait-on ce travail correctement? Je veux pouvoir revenir à partir de la DLL, une structure qui contient toutes les informations dont j'ai besoin. C'est-à-dire, dans cet exemple, le nombre d'éléments et le pointeur vers le tableau. De cette façon, je peux alors faire un Marshal.Copy sur l'intptr, pour obtenir le tableau.

S'il y a une autre façon de le faire, je suis plus qu'heureux de le faire. J'ai essayé plusieurs façons déjà, en vain. Cela inclut d'essayer la structure suivante en C# (qui contient le tableau int, plutôt que IntPtr):

public struct TestStruct 
{ 
    public int num; 

    // i have tried various methods to marshal this- eg: 
    // [MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_I4] 
    public int[] intArray; 
} 

Et j'ai aussi essayé passer la structure par référence elle-même, plutôt que d'un IntPtr. Toute aide à ce sujet serait massivement appréciée. Je suis incapable de changer le code C++, mais le code C# peut être changé.

Answer 1

tout d'abord changer le code C++ pour utiliser un seul niveau d'indirection:

extern "C" __declspec(dllexport) void Dll_TestArray(TestStruct &testStruct) 
{ 
    const int num = 15; 
    testStruct.num = num; 
    testStruct.intArray = new int[num]; 
    for (int i=0; i<num; i++) 
     testStruct.intArray[i] = i+1; 
} 

Du côté C# vous voulez ceci:

public struct TestStruct 
{ 
    public int num; 
    public IntPtr intArray; 
} 

[DllImport("testing.dll", CallingConvention=CallingConvention.Cdecl)] 
static extern void Dll_TestArray(out TestStruct testStruct); 

public GetArray() 
{ 
    TestStruct testStruct; 
    Dll_TestArray(out testStruct); 
    int[] arr = new int[testStruct.num]; 
    Marshal.Copy(testStruct.intArray, arr, 0, arr.Length); 
    // need to call back to DLL to ask it to deallocate testStruct.intArray 
} 

Vous aurez également besoin d'exporter une fonction Cela libérera le tableau que vous avez alloué en utilisant le tas C++. Sinon, vous le ferez.

Peut-être une approche plus simple serait de changer la conception pour que l'appelant alloue le tampon.