Comment convertir un tableau de valeur struct en octets?

Question

J'ai un System.Array de types struct de valeur, quelque chose comme ceci:

public value struct Position 
{ 
    int timestamp; 
    float x; 
    float y; 
} 

Position[] positions = new Position[1000 * 1000]; 

Après avoir initialiser le tableau avec des valeurs, comment puis-je obtenir un byte[] de son contenu, sans sérialisation un élément à la fois?

En C++/CLI, j'utiliserais un pin_ptr pour obtenir le pointeur sur le contenu du tableau et je copierais les données à partir de là. Puis-je faire quelque chose comme ça en C#?

EDIT: J'ai besoin d'écrire les données brutes sur le disque, comme s'il s'agissait d'une structure C, sans aucun type de sérialisation. J'ai marqué cette question en tant que C# pour une exposition plus large, mais en fait j'essaie de sérialiser les données de IronPython, donc cela signifie que je ne peux pas utiliser la fonctionnalité unsafe C#.

Answer 1

est ici une méthode qui ne nécessite pas de code dangereux :

[Mis à jour pour supprimer la boucle for et effectuer la copie en un seul passage]

private static byte[] StructureToByteArray(Position[] posArray) 
{ 
    if (posArray == null || posArray.Length == 0) 
    { 
     return new byte[0]; 
    } 

    var lenOfObject = Marshal.SizeOf(typeof(Position)); 
    var len = lenOfObject * posArray.Length; 
    var arr = new byte[len]; 

    var handle = GCHandle.Alloc(posArray, GCHandleType.Pinned); 
    try 
    { 
     var ptr = handle.AddrOfPinnedObject(); 
     Marshal.Copy(ptr, arr, 0, len); 
    } 
    finally 
    { 
     handle.Free(); 
    } 

    return arr; 
} 

Answer 2

Peut-être que cela vous aidera:

[Serializable()] 
    public struct Position 
    { 
     int timestamp; 
     float x; 
     float y; 
    } 


    static void Main(string[] args) 
    { 
     var positions = new Position[1000 * 1000]; 
     GetBytes(positions); 
    } 
    private static byte[] GetBytes(object obj) 
    { 
     using (var memoryStream = new System.IO.MemoryStream()) 
     { 
      var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); 
      binaryFormatter.Serialize(memoryStream, obj); 
      return memoryStream.ToArray(); 
     } 
    } 

Answer 3

Je crois que c'est l'équivalent du C++/CLI pin_ptr en utilisant le code dangereux C#:

public static unsafe byte[] GetBytes(Position[] positions) 
    { 
     byte[] result = new byte[positions.Length * Marshal.SizeOf(typeof(Position))]; 
     fixed (Position* ptr = &positions[0]) 
     { 
      Marshal.Copy((IntPtr)ptr, result, 0, result.Length); 
     } 
     return result; 
    }