Marshalling eines Zeigers auf ein Array von Typen (verwaltetes C# -> nicht verwaltetes C++)

Question

Ich habe einige Schwierigkeiten bei der Festlegung einer Struktur, die einen Zeiger auf ein Array von Kurzschlüssen in meinem verwalteten Code enthält. Die Struktur sieht wie folgt aus:

typedef struct 
{ 
    short size; 
    unsigned short** shortValues; 
} UnmanagedStruct; 

Speicher für ‚shortValues‘ innerhalb unmanaged Code zugeordnet ist - also auch wenn das Feld zu einer Reihe von kurzen Werten ein zusätzlicher Dereferenzierungsebene einfach ein Zeiger wurde hinzugefügt, so dass Der zugewiesene Speicher wird vom Aufrufer (verwalteter Code) ebenfalls gesehen. Das Feld 'size' repräsentiert die Anzahl der Elemente im Array. Wie stelle ich dies in verwaltetem Code dar?

Ich dachte, ich würde es nur in einem IntPtr übergeben, dann konnte ich nicht herausfinden, wie auf die Werte zugreifen, sobald der unmanaged Anruf zurückkehrt.

Answer 1

Ist unsicherer Code in Ordnung?

public unsafe struct UnmanagedStruct 
{ 
    public short size; 
    public ushort** shortValues; 
} 

[DllImport("example.dll")] 
public static extern void GetUnmanagedStruct(out UnmanagedStruct s); 

Wenn Sie einen Zeiger auf ein Array von ushort s:

public static unsafe void WriteValues() 
{ 
    UnmanagedStruct s; 
    GetUnmanagedStruct(out s); 
    for (var i = 0; i < s.size; i++) 
    { 
     ushort x = (*s.shortValues)[i]; 
     Console.WriteLine(x); 
    } 
} 

Wenn Sie ein Array von nullterminierten Arrays von ushort s haben:

public static unsafe void WriteValues() 
{ 
    UnmanagedStruct s; 
    GetUnmanagedStruct(out s); 
    for (var i = 0; i < s.size; i++) 
    { 
     for (ushort* p = s.shortValues[i]; p != null; p++) 
     { 
      ushort x = *p; 
      Console.WriteLine(x); 
     } 
    } 
} 

Answer 2

Sorry, Jungs. Ich habe die Problemstellung falsch verstanden. Es sieht so aus:

unsigned short ** shortValues;

ist ein Zeiger auf Array von Zeiger auf Kurzschlüsse. Also jedes Element selbst eine kurze *

Die einzige Art, wie ich dies zu tun denken kann, ist:

public class UnmanagedStruct { public int size; public IntPtr shortValues; }

Nach dem Aufruf kehrt von nicht verwalteten Code:

IntPtr [] listOfShorts = new IntPtr [size]; Marshal.Copy (shortValues, listOfShorts, 0, Größe);

Jedes IntPtr in listOfShorts zeigt jetzt auf einen kurzen []. Aber jetzt ist das Problem, ich kenne die Größe jedes einzelnen Arrays nicht, was bedeutet, dass ich sie nicht extrahieren kann.

Ich muss irgendwo wichtige Informationen fehlen.