interfacciamento con D correttamente restituire un array di Struct

Question

questa domanda si riferisce al 'nuovo' D: DMD32 D Compiler v2.068.2

per TL; DR se non è necessario Salta alla domanda qui sotto

lavorare con visual Studio (sto usando v2010), con la creazione di un new project ->D ->Dynamic Library

quando il processo del progetto creartion è completa, nella soluzione Explorer c'è 2 file:

• dllmain.d
• dll.def

lasciando il file .def così com'è, sono riuscito per capire che con l'aggiunta di alcune nuove funzioni al dllmain.d e prefexing con:

extern (Windows) export 

esporterà la funzione e sarà richiamabile da c#, non provato con C o C++.

_{nota a margine, non toccare nessuno dei codici esistenti a meno che non si sappia cosa si sta facendo.}

in modo che il codice qui sotto funziona come previsto

extern (Windows) export uint D_mathPower(uint p) 
{  
    return p * p; 
} 

chiamandolo da C# con la seguente firma:

[DllImport(@"pathTo...\DynamicLib1.dll", CallingConvention = CallingConvention.StdCall), SuppressUnmanagedCodeSecurity] 
    public static extern uint D_mathPower(uint p); 

potrei facile usarlo come segue:

uint powD = D_mathPower(5); 

la mia domanda è

Come restituire un array di strutture (preferibilmente il modo più conveniente)?

struct dpack{ char* Name; uint Id; } 

ho provato utilizzando sia char[] e char* ma senza successo.

questo è il mio codice finora

extern (Windows) export 
dpack[] D_getPacks(uint size) 
{ 
    dpack[] rtDpArr = new dpack[size]; 
    char[] str = "someText".dup; 

    for(uint i=0; i<size; i++) 
    { 

     str[$ - 1] = cast(char)('0' + i % (126 - '0')); 
     rtDpArr[i].Id = i; 
     rtDpArr[i].Name= str.dup; 
    } 
    return rtDpArr; 
} 


void getPacksPtr(uint size, dpack** DpArr) 
{ 
// this is the signature i have successfully implemented via c++ 
} 

Answer 1

Perché una matrice D ha un layout speciale si dovrebbe piuttosto restituire un puntatore alla prima voce. Poi in C# è possibile lanciare ogni elemento dal puntatore base con la lettura di 8 byte per 8 byte (questo corrisponde dpack.sizeof), dal momento che si conosce già il conteggio:

struct dpack{ immutable(char)* Name; uint Id; } 

extern (Windows) export 
void* D_getPacks(uint count) 
{ 
    dpack[] rtDpArr = new dpack[count]; 
    char[] str = "someText".dup; 

    import std.string; 
    for(uint i=0; i<count; i++) 
    { 
     rtDpArr[i].Id = i; 
     // add a trailing '\0' 
     rtDpArr[i].Name = toStringz(str); 
    } 
    // pointer to the first item 
    return rtDpArr.ptr; 
} 

anche per lanciare il membro .Name è necessario aggiungere un terminatore, altrimenti non puoi sapere la lunghezza della stringa.Questo è fatto da std.string.toStringz che aggiungerà un carattere null alla fine della stringa. Il membro char* Name può quindi essere lanciato come di solito sono le stringhe fornite da una funzione in una DLL con un'interfaccia C.

Answer 2

questo è il modo più efficiente per implementarlo.

extern (Windows) export 
void D_getPacksPtr(uint size, dpack** DpArr) 
{ 
    *DpArr = cast(dpack*) malloc(size * dpack.sizeof); 
    dpack* curP = *DpArr; 
    char[] str = "abcdefghij".dup; 
    uint i=0; 
    while(i!=size){ 
     str[$ - 1] = cast(char)('0' + i % (126 - '0')); 
     curP.Name = cast(char*)str.dup; curP.Id = i; 
     ++i;++curP; 
    } 
} 

    [DllImport(@"PathTo...\DynamicLib1.dll", CallingConvention = CallingConvention.StdCall), SuppressUnmanagedCodeSecurity] 
    public static extern void D_getPacksPtr(uint size, dpack** DPArr); 

usarlo:

dpack* outDpack; 
    D_getPacksPtr(500000, &outDpack);