Comment convertir des structures C# vers et depuis des tableaux d'octets à l'aide du marshaling ?

Convertir la structure en tableau d'octets en C#

Lors de la transmission de données sur le réseau ou de leur stockage dans un fichier binaire, il est souvent nécessaire de convertir la structure en un tableau d'octets. Une structure est un type de valeur qui contient plusieurs éléments de données associés, tandis qu'un tableau d'octets est un bloc continu de données binaires.

Définition de la structure

Considérez la structure C# suivante représentant un paquet CIFS (Common Internet File System) :

<code class="language-csharp">public struct CIFSPacket
{
    // ... various fields ...
    public string Buffer;
}</code>

Fonction de conversion

Pour convertir une structure en tableau d'octets, vous pouvez utiliser la méthode StructToPtr de la classe Marshal. Cette méthode accepte deux paramètres :

• Structure : La structure à aménager.
• Pointeur : Le pointeur de départ du tableau d'octets où les données converties seront stockées.

Ce qui suit est une fonction qui convertit une structure CIFSPacket en un tableau d'octets :

<code class="language-csharp">public static byte[] getBytes(CIFSPacket str)
{
    int size = Marshal.SizeOf(str);
    byte[] arr = new byte[size];

    IntPtr ptr = IntPtr.Zero;
    try
    {
        ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(str, ptr, true);
        Marshal.Copy(ptr, arr, 0, size);
    }
    finally
    {
        Marshal.FreeHGlobal(ptr);
    }
    return arr;
}</code>

Triage des cordes

Pour rassembler correctement les chaînes, nous devons utiliser l'attribut MarshalAs. Par exemple, si notre champ Buffer est une chaîne, nous pouvons l'annoter comme suit :

<code class="language-csharp">[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 100)]
public string Buffer;</code>

Cet attribut indique que la chaîne doit être transformée en une chaîne de longueur fixe terminée par un caractère nul et d'une taille maximale de 100 caractères.

Restaurer la structure

Une fois que nous avons la représentation sous forme de tableau d'octets de la structure, nous pouvons restaurer la structure en utilisant la méthode PtrToStructure de la classe Marshal. Cette méthode accepte deux paramètres :

• Pointeur : Le pointeur de départ du tableau d'octets contenant les données de structure.
• Type : Le type de structure à créer.

Ce qui suit est une fonction qui reconvertit un tableau d'octets en une structure CIFSPacket :

<code class="language-csharp">public static CIFSPacket fromBytes(byte[] arr)
{
    CIFSPacket str = new CIFSPacket();

    int size = Marshal.SizeOf(str);
    IntPtr ptr = IntPtr.Zero;
    try
    {
        ptr = Marshal.AllocHGlobal(size);

        Marshal.Copy(arr, 0, ptr, size);

        str = (CIFSPacket)Marshal.PtrToStructure(ptr, str.GetType());
    }
    finally
    {
        Marshal.FreeHGlobal(ptr);
    }
    return str;
}</code>

Comment utiliser

Pour utiliser ces fonctions, transmettez simplement la structure CIFSPacket à la fonction getBytes pour obtenir sa représentation sous forme de tableau d'octets. Vous pouvez également transmettre un tableau d'octets à la fonction fromBytes pour recréer la structure d'origine.

En tirant parti de la technologie de marshalling, nous pouvons facilement convertir les structures en tableaux d'octets et inversement, permettant une transmission et un stockage efficaces des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!