¿Cómo identifico un puntero a un puntero de una matriz de estructuras?

Question

Mis C declaraciones son las siguientes:

int myData(uint myHandle, tchar *dataName, long *Time, uint *maxData, DATASTRUCT **data); 

typedef struct { 
    byte Rel; 
    __int64 Time; 
    char Validated; 
    unsigned char Data[1]; 
} DATASTRUCT ; 

Mi C# declaraciones son las siguientes:

[DllImport("myData.dll", EntryPoint = "myData")] 
public static extern int myData(uint myHandle, [MarshalAs(UnmanagedType.LPTStr)] string dataName, out long Time, out uint maxData, ref DATASTRUCT[] data); 

[StructLayout(LayoutKind.Sequential, Pack = 1)] 
public struct DATASTRUCT 
{ 
    public sbyte Rel; 
    public long Time; 
    public byte Validated; 
    public double Data; 
} 

entonces llamar a la función administrada de la siguiente manera:

string dataToShow = "description"; 
long Time; 
uint maxData; // How many structs will be returned, i.e. how much data is available 
uint myHandle = 1; 

DATASTRUCT[] dataInformation = new DATASTRUCT[3]; // doesn't matter what I specify as the array size? 

myData(myHandle, dataToShow, out Time, out maxData, ref dataInformation); 

Tras la ejecución de lo anterior la función regresará con éxito con solo una estructura aunque haya 3 para regresar. ¿Por qué esto es tan?

Información adicional; He tratado de pasar el puntero a un puntero de una serie de estructuras de las siguientes maneras:

- ref DATASTRUCT[] data; // Works but only returns one struct 
- [Out, MarshalAs(UnmanagedType.LPArray)] DATASTRUCT[] data; // returns the number of defined structs with garbage 

Según entiendo que podría necesitar hacer un poco de clasificación manual utilizando IntPtr, no sé cómo implementar esto, sin embargo, entonces cualquier consejo sería apreciado.

Answer 1

De acuerdo, parece que su biblioteca nativa realiza la asignación, de modo que todo lo que necesita hacer es proporcionar un puntero a través del cual puede acceder a los datos asignados.

Cambiar la definición API para (nota, he cambiado el parámetro maxdata a uint, larga es de 64 bits de .NET y 32 bits en nativo.

[DllImportAttribute("myData.dll", EntryPoint = "myData")] 
public static extern int myData(uint myHandle, [MarshalAs(UnmanagedType.LPTStr)] string dataName, out uint Time, out uint maxData, out IntPtr pData); 

De la parte superior de mi cabeza no puedo . me acuerdo bien si necesita la palabra clave a cabo para el parámetro final, pero creo que sí

Luego, llame myData:

uint nAllocs = 0, time = 0; 
IntPtr pAllocs = IntPtr.Zero; 
myData(1, "description", out time, out nAllocs, out pAllocs); 

Ahora, pAllocs deben apuntar a la memoria no administrada, para reunir estos int o memoria administrada no es demasiado difícil:

[StructLayoutAttribute(LayoutKind.Sequential, Pack = 1)] 
public struct DATASTRUCT 
{ 
    public byte Rel; 
    public long Time; 
    public byte Validated; 
    public IntPtr Data; //pointer to unmanaged string. 
} 


int szStruct = Marshal.SizeOf(typeof(DATASTRUCT)); 
DATASTRUCT[] localStructs = new DATASTRUCT[nAllocs]; 
for(uint i = 0; i < nallocs; i++) 
    localStructs[i] = (DATASTRUCT)Marshal.PtrToStructure(new IntPtr(pAllocs.ToInt32() + (szStruct * i)), typeof(DATASTRUCT)); 

Y ahora debe tener una serie de estructuras locales.

Un punto a tener en cuenta Es posible que tenga que configurar su proyecto para compilar como x86, para estandarizar el tamaño de un IntPtr a 4 bytes (DWORD) en lugar de por defecto de 8 Cualquier CPU.

Answer 2

Un puntero a un puntero podría ser representado en su declaración dllimport como datos ref IntPtr, por lo que su declaración se convertiría en:

[DllImportAttribute("myData.dll", EntryPoint = "myData")] 
public static extern int myData(uint myHandle, [MarshalAs(UnmanagedType.LPTStr)] string dataName, out long Time, out uint maxData, ref IntPtr data); 

(Dicho sea de paso, creo mucho en C es sólo equivalente a una int en C#. largo en C# es un Int64, lo que sería un largo tiempo en C)

Marshalling su DATASTRUCT [] a un IntPtr se puede hacer uso de la clase GCHandle

DATASTRUCT [] dataInformation = new DATASTRUCT[3]; 
GCHandle gch = GCHandle.Alloc(dataInformation , GCHandleType.Pinned); 
IntPtr ptr = gch.AddrOfPinnedObject(); 
myData(myHandle, dataToShow, out Time, out maxData, ref ptr); 
//It's absolutely essential you do this next bit so the object can be garbage collected again, 
//but it should only be done once the unmanaged code is definitely done with the reference.  
gch.Free(); 

Usar la clase Marshal y los métodos StructureToPtr o Copy también sería una opción, pero a los efectos de probar el concepto, al menos, el GCHandle debería hacer el truco, simplemente no es ideal para escenarios donde el código no administrado hace largas operaciones porque usted He inmovilizado este objeto en su lugar y el GC no puede moverlo hasta que lo liberes.