Marshal eine C-Struktur mit einem Array variabler Länge

Question

Ich möchte eine C-Struktur mit einem Array variabler Länge zurück zu C# marshale aber bis jetzt kann ich nichts besseres als eine Zeiger-zu-Struktur-Darstellung und einen Zeiger bekommen schweben.

Unmanaged Darstellung:

typedef float  smpl_t; 

typedef struct { 
    uint_t length; /**< length of buffer */ 
    smpl_t *data; /**< data vector of length ::fvec_t.length */ 
} fvec_t; 

Managed Darstellung:

[StructLayout(LayoutKind.Sequential)] 
public unsafe struct fvec_t1 
{ 
    public uint length; 

    public float* data; 
} 

[DllImport("libaubio-4.dll", EntryPoint = "new_fvec", PreserveSig = true, CharSet = CharSet.Ansi, 
    CallingConvention = CallingConvention.Cdecl)] 
public static extern unsafe fvec_t1* new_fvec1(uint length); 

Was Ich mag würde, ist eine .NET-Stil-Array haben, wo datafloat[] sein würde, aber wenn ich ändern tun, um die Struktur zu das Formular unten bekomme ich Kann die Adresse nicht übernehmen, erhalten die Größe von, oder einen Zeiger auf einen verwalteten Typ in der externen Funktion oben deklarieren.

[StructLayout(LayoutKind.Sequential)] 
public unsafe struct fvec_t1 
{ 
    public uint length; 

    public float[] data; 
} 

Apparently, ist es nicht möglich, eine einen variabler Länge Array vermarshallten zurück wie sie ist, dies richtig ist oder ist es immer noch eine Möglichkeit, dies zu erreichen?

Answer 1

kurze Antwort Sie nicht mit variabler Länge Array als Array Marschall kann, denn ohne die Größe zu kennen, kann die Interop-Rangier-Dienst nicht auf die Array-Elemente Marschall

aber wenn Sie die Größe, die es wie unten sein wird:

int arr[15] 

Sie werden in der Lage sein, es so Marschall:

[MarshalAs(UnmanagedType.LPArray, SizeConst=15)] int[] arr 

, wenn Sie nicht wissen, die Länge des Arrays einer d das ist, was Sie möchten, können Sie es konvertieren mit InPtr intprt und befassen sich aber zuerst müssen Sie 2 structs wie unten

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
struct fvec_t1 
{ 
    public uint whatever; 

    public int[] data; 
} 

die andere erstellen:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
struct fvec_t2{ 
    public uint whatever; 
} 

eine Funktion erstellen, initialisieren das Array wie unten

private static int[] ReturnIntArray() 
{ 
    int [] myInt = new int[30]; 

    for (int i = 0; i < myInt.length; i++) 
    { 
     myInt[i] = i + 1; 
    } 

    return myInt; 
} 

Instanziieren der erste struct

fvec_t1 instance = new fvec_t1(); 
instance.whatever=10; 
instance.data= ReturnIntArray(); 

instanziieren die zweite struct

fvec_t2 instance1 = new fvec_t2(); 

instance1.whatever = instance.whatever 

dynamisch Raum für fvec_t2 struct für Datenarray mit erweiterter Raum zuzuteilen

IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(fvec_t2)) + Instance.data.Length); 

Übertragung die bestehenden Feldwerte von fvec_t2 an Speicherplatz von PTR zeigte

Marshal.StructureToPtr(instance1, ptr, true); 

Berechnen Sie den Offset des Datenfelds, das b e am Ende eines fvec_t2 struct

int offset = Marshal.SizeOf(typeof(fvec_t2)); 

bekommen Speicheradresse des Datenarray Feld basierend auf dem Versatz.

IntPtr address = new IntPtr(ptr.ToInt32() + offset); 

Datenkopie

Marshal.Copy(instance.data, 0, address, instance.data.Length); 

tun den Anruf

bool success = dllfunction(ptr); 

Marshal.FreeHGlobal(ptr); 
ptr = IntPtr.Zero; 

Answer 2

Im obigen Fall ptr ich auf jeden Fall die SizeParamIndex verwenden würde.

[StructLayout(LayoutKind.Sequential)] 
public struct fvec_t1 
{ 
    uint length; 
    [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] float[] data; 
} 

Viel Glück.