Umgang mit Zeigern zu Struktur in C#

Question

Ich arbeite an einem Projekt, das in C++ geschriebene DLL und einen C# -Code enthält. Lassen Sie uns sagen, dass diese DLL eine Funktion hat:

MyStruct* GetPointer(); // returns pointer to MyStruct structure 

MyStruct Struktur sieht wie folgt aus:

struct MyStruct 
{ 
    OtherStruct1 *data1; 
    OtherStruct2 *data2; 
}; 

Und OtherStruct1 und OtherStruct2 Strukturen wie folgt aussehen:

struct OtherStruct1 
{ 
public: 
    double x; 
    char y; 
}; 

struct OtherStruct2 
{ 
public: 
    float a; 
    float b; 
    float c; 
    float d; 
}; 

Meine Frage ist - was ist Der beste Weg, um alle diese Zeiger in einem C# -Code zu behandeln? Mit "Handhabung" meine ich Lese- und Speichervorgänge. Strukturen in C# können nicht einfach Zeigervariablen enthalten. Was soll ich machen? Was ist der eleganteste Weg?

Answer 1

Sie können das Microsoft (jetzt Open Source) PInvoke Interop Assistant Tool verwenden, um Ihren C/C++ Code in C# oder VB zu konvertieren. Starten Sie Ihren Beispielcode gibt:

[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] 
public struct MyStruct { 

    /// OtherStruct1* 
    public System.IntPtr data1; 

    /// OtherStruct2* 
    public System.IntPtr data2; 
} 

[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] 
public struct OtherStruct1 { 

    /// double 
    public double x; 

    /// char 
    public byte y; 
} 

[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] 
public struct OtherStruct2 { 

    /// float 
    public float a; 

    /// float 
    public float b; 

    /// float 
    public float c; 

    /// float 
    public float d; 
} 

public partial class NativeMethods { 

    /// Return Type: MyStruct* 
    [System.Runtime.InteropServices.DllImportAttribute("<Unknown>", EntryPoint="GetPointer")] 
public static extern System.IntPtr GetPointer() ; 

} 

Ersetzen Sie „Unknown“ im DllImportAttribute mit Ihrem DLL-Namen, und stellen Sie sicher, dass es im Projekt verwiesen wird. Sie sollten jetzt in verwaltetem Code auf Ihre Strukturen zugreifen können.

Anschließend müssen Sie die Methoden im System.Runtime.InteropServices.Marshal-Namespace verwenden, um von/in den Speicher zu lesen/schreiben. Der folgende Codeausschnitt zeigt, wie Sie Ihre GetPointer Funktion benutzen, um Ihre nicht verwalteten Struktur in eine Eins geschafft zu bekommen:

IntPtr myPtr = NativeMethods.GetPointer(); Call native code to retrieve pointer to unmanaged memory where the struct lives 
MyStruct myStruct = new MyStruct(); // Create a new managed struct 
myStruct = Marshal.PtrToStructure<MyStruct>(myPtr); 

Und hier ist, wie Sie eine verwaltete Struktur an eine nicht verwaltete Methode übergeben würde:

MyStruct myStruct = new MyStruct(); // Create the managed struct 
myStruct.data1 = new OtherStruct1(); // Create a managed OtherStruct1 
myStruct.data2 = new OtherStruct2(); // Create a managed OtherStruct2 
IntPtr myStructPtr = Marshal.AllocHGlobal(Marshal.SizeOf<MyStruct>()); // Allocate unmanaged memory for the struct 
Marshal.StructureToPtr<MyStruct>(myStruct, myStructPtr, false); 
try 
{ 
    NativeMethodThatUsesMyStructPtr(myStructPtr); 
} 
finally 
{ 
    Marshal.FreeHGlobal(myStructPtr); // *** You have to free unmanaged memory manually, or you will get a memory leak! *** 
} 

Answer 2

Ok, ich habe einen Weg gefunden, es zu tun.

[StructLayout(LayoutKind.Sequential)] 
struct MyStruct 
{ 
    OtherStruct1 *data1; 
    OtherStruct2 *data2; 
}; 

[StructLayout(LayoutKind.Sequential)] 
struct OtherStruct1 
{ 
public: 
    double x; 
    char y; 
}; 

[StructLayout(LayoutKind.Sequential)] 
struct OtherStruct2 
{ 
public: 
    float a; 
    float b; 
    float c; 
    float d; 
}; 

Und dann:

unsafe 
{ 
    MyStruct *tmp = (MyStruct*) GetPointer(); 
    tmp->data2[0].a = 1.0F; 
} 


[DllImport(DLL_PATH, CallingConvention = CallingConvention.Cdecl)] 
    unsafe public static extern MyStruct* GetPointer(); 

Arbeiten wie ein Charme. :)