Comment puis-je marsher une structure qui contient un tableau de taille variable à C#?

question ancienne, mais j'ai récemment dû le faire moi-même et toutes les réponses existantes sont pauvres, donc...

la meilleure solution pour regrouper un réseau de longueur variable dans une structure est d'utiliser un custom marshaler . Cela vous permet de contrôler le code que l'exécution utilise pour convertir entre les données gérées et non gérées. Malheureusement, la mise en service sur mesure est mal documentée et comporte quelques limites bizarres. Je vais couvrir ceux rapidement, puis passer en revue la solution.

fâcheusement, vous ne pouvez pas utiliser la composition personnalisée sur un élément de tableau d'une structure ou d'une classe. Il n'y a aucune raison documentée ou logique pour cette limitation, et le compilateur ne se plaindra pas, mais vous obtiendrez une exception à l'exécution. En outre, il ya une fonction que les marshalers coutume doit mettre en œuvre, int GetNativeDataSize() , qui est évidemment impossible à mettre en œuvre avec précision (il ne vous passe pas une instance de l'objet pour demander sa taille, de sorte que vous pouvez seulement aller le type, qui est bien sûr variable de taille!) Heureusement, cette fonction n'a pas d'importance. Je ne l'ai jamais vu se faire appeler, et il fonctionne très bien même s'il renvoie une valeur bidon (un exemple MSDN le renvoie -1).

tout d'abord, voici à quoi je pense que votre prototype natif pourrait ressembler (j'utilise P/Invoke ici, mais cela fonctionne aussi pour COM):

// Unmanaged C/C++ code prototype (guess)
//void DoThing (ABS_DATA *pData);

// Guess at your managed call with the "marshal one-byte ByValArray" version
//[DllImport("libname.dll")] public extern void DoThing (ref abs_data pData);

Voici la version naïve de comment vous avez pu utiliser une coutume marshaleur (qui devraient avoir travaillé). Je vais arriver à le marshaleur lui-même en un peu...

[StructLayout(LayoutKind.Sequential)]
public struct abs_data
{
    // Don't need the length as a separate filed; managed arrays know it.
    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(ArrayMarshaler<byte>))]
    public byte[] Data;
}

// Now you can just pass the struct but it takes arbitrary sizes!
[DllImport("libname.dll")] public extern void DoThing (ref abs_data pData);

malheureusement, à l'exécution, vous ne pouvez apparemment pas marshal tableaux à l'intérieur des structures de données comme quoi que ce soit sauf SafeArray ou ByValArray . Les SafeArrays sont comptés, mais ils ne ressemblent en rien au format (extrêmement commun) que vous recherchez ici. Donc cela ne marchera pas. ByValArray, bien sûr, exige que la longueur soit connue au moment de la compilation, travailler soit (comme vous avez couru dans). Bizarrement, cependant, vous can utilisez le marshaling personnalisé sur le tableau paramètres , c'est ennuyeux parce que vous devez mettre le MarshalAsAttribute sur chaque paramètre qui utilise ce type, au lieu de simplement le mettre sur un champ et ayant qui s'appliquent partout, vous utilisez le type contenant ce champ, mais c'est la vie. Il ressemble à ceci:

[StructLayout(LayoutKind.Sequential)]
public struct abs_data
{
    // Don't need the length as a separate filed; managed arrays know it.
    // This isn't an array anymore; we pass an array of this instead.
    public byte Data;
}

// Now you pass an arbitrary-sized array of the struct
[DllImport("libname.dll")] public extern void DoThing (
    // Have to put this huge stupid attribute on every parameter of this type
    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(ArrayMarshaler<abs_data>))]
    // Don't need to use "ref" anymore; arrays are ref types and pass as pointer-to
    abs_data[] pData);

dans cet exemple, j'ai conservé le abs_data type, dans le cas où vous voulez faire quelque chose de spécial avec elle (constructeurs, fonctions statiques, propriétés, héritage, quoi que ce soit). Si votre tableau elements se composait d'un type complexe, vous modifieriez la structure pour représenter ce type complexe. Cependant, dans ce cas, abs_data est fondamentalement juste un byte renommé - il n'est même pas "envelopper" le byte; en ce qui concerne le code natif il est plus comme un typedef - donc vous pouvez juste passer un tableau d'octets et sauter entièrement la structure:

// Actually, you can just pass an arbitrary-length byte array!
[DllImport("libname.dll")] public extern void DoThing (
    // Have to put this huge stupid attribute on every parameter of this type
    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(ArrayMarshaler<byte>))]
    byte[] pData);

OK, donc maintenant vous pouvez voir comment déclarer le type d'élément du tableau (si nécessaire), et comment passer le tableau à une fonction non gérée. Toutefois, nous avons encore besoin que marshaleur personnalisé. Vous devriez lire " implémenter L'Interface ICustomMarshaler " mais je vais couvrir ceci ici, avec des commentaires en ligne. Notez que j'utilise certaines conventions de raccourci (comme Marshal.SizeOf<T>() ) qui requièrent .NET 4.5.1 ou plus.

// The class that does the marshaling. Making it generic is not required, but
// will make it easier to use the same custom marshaler for multiple array types.
public class ArrayMarshaler<T> : ICustomMarshaler
{
    // All custom marshalers require a static factory method with this signature.
    public static ICustomMarshaler GetInstance (String cookie)
    {
        return new ArrayMarshaler<T>();
    }

    // This is the function that builds the managed type - in this case, the managed
    // array - from a pointer. You can just return null here if only sending the 
    // array as an in-parameter.
    public Object MarshalNativeToManaged (IntPtr pNativeData)
    {
        // First, sanity check...
        if (IntPtr.Zero == pNativeData) return null;
        // Start by reading the size of the array ("Length" from your ABS_DATA struct)
        int length = Marshal.ReadInt32(pNativeData);
        // Create the managed array that will be returned
        T[] array = new T[length];
        // For efficiency, only compute the element size once
        int elSiz = Marshal.SizeOf<T>();
        // Populate the array
        for (int i = 0; i < length; i++)
        {
            array[i] = Marshal.PtrToStructure<T>(pNativeData + sizeof(int) + (elSiz * i));
        }
        // Alternate method, for arrays of primitive types only:
        // Marshal.Copy(pNativeData + sizeof(int), array, 0, length);
        return array;
    }

    // This is the function that marshals your managed array to unmanaged memory.
    // If you only ever marshal the array out, not in, you can return IntPtr.Zero
    public IntPtr MarshalManagedToNative (Object ManagedObject)
    {
        if (null == ManagedObject) return IntPtr.Zero;
        T[] array = (T[])ManagedObj;
        int elSiz = Marshal.SizeOf<T>();
        // Get the total size of unmanaged memory that is needed (length + elements)
        int size = sizeof(int) + (elSiz * array.Length);
        // Allocate unmanaged space. For COM, use Marshal.AllocCoTaskMem instead.
        IntPtr ptr = Marshal.AllocHGlobal(size);
        // Write the "Length" field first
        Marshal.WriteInt32(ptr, array.Length);
        // Write the array data
        for (int i = 0; i < array.Length; i++)
        {   // Newly-allocated space has no existing object, so the last param is false
            Marshal.StructureToPtr<T>(array[i], ptr + sizeof(int) + (elSiz * i), false);
        }
        // If you're only using arrays of primitive types, you could use this instead:
        //Marshal.Copy(array, 0, ptr + sizeof(int), array.Length);
        return ptr;
    }

    // This function is called after completing the call that required marshaling to
    // unmanaged memory. You should use it to free any unmanaged memory you allocated.
    // If you never consume unmanaged memory or other resources, do nothing here.
    public void CleanUpNativeData (IntPtr pNativeData)
    {
        // Free the unmanaged memory. Use Marshal.FreeCoTaskMem if using COM.
        Marshal.FreeHGlobal(pNativeData);
    }

    // If, after marshaling from unmanaged to managed, you have anything that needs
    // to be taken care of when you're done with the object, put it here. Garbage 
    // collection will free the managed object, so I've left this function empty.
    public void CleanUpManagedData (Object ManagedObj)
    { }

    // This function is a lie. It looks like it should be impossible to get the right 
    // value - the whole problem is that the size of each array is variable! 
    // - but in practice the runtime doesn't rely on this and may not even call it.
    // The MSDN example returns -1; I'll try to be a little more realistic.
    public int GetNativeDataSize ()
    {
        return sizeof(int) + Marshal.SizeOf<T>();
    }
}

Ouf, c'était long! Eh bien, là vous l'avez. J'espère que les gens voient cela, parce qu'il y a beaucoup de mauvaises réponses et de l'incompréhension...