Comment convertir un objet en tableau d'octets en C #

J'ai une collection d'objets dont j'ai besoin pour écrire dans un fichier binaire.

J'ai besoin que les octets du fichier soient compacts, donc je ne peux pas utiliser BinaryFormatter. BinaryFormatterjette toutes sortes d'informations pour les besoins de désérialisation.

Si j'essaye

byte[] myBytes = (byte[]) myObject 

J'obtiens une exception d'exécution.

J'ai besoin que cela soit rapide, donc je préfère ne pas copier des tableaux d'octets. J'aimerais juste que le casting byte[] myBytes = (byte[]) myObjectfonctionne!

OK pour être clair, je ne peux pas avoir de métadonnées dans le fichier de sortie. Juste les octets de l'objet. Objet à objet emballé. Sur la base des réponses reçues, il semble que j'écrirai du Buffer.BlockCopycode de bas niveau . Peut-être en utilisant un code non sécurisé.

Pour convertir un objet en tableau d'octets:

// Convert an object to a byte array
public static byte[] ObjectToByteArray(Object obj)
{
    BinaryFormatter bf = new BinaryFormatter();
    using (var ms = new MemoryStream())
    {
        bf.Serialize(ms, obj);
        return ms.ToArray();
    }
}

Il vous suffit de copier cette fonction dans votre code et de lui envoyer l'objet que vous devez convertir en un tableau d'octets. Si vous avez besoin de convertir à nouveau le tableau d'octets en objet, vous pouvez utiliser la fonction ci-dessous:

// Convert a byte array to an Object
public static Object ByteArrayToObject(byte[] arrBytes)
{
    using (var memStream = new MemoryStream())
    {
        var binForm = new BinaryFormatter();
        memStream.Write(arrBytes, 0, arrBytes.Length);
        memStream.Seek(0, SeekOrigin.Begin);
        var obj = binForm.Deserialize(memStream);
        return obj;
    }
}

Vous pouvez utiliser ces fonctions avec des classes personnalisées. Il vous suffit d'ajouter l' [Serializable]attribut dans votre classe pour activer la sérialisation

Si vous voulez que les données sérialisées soient vraiment compactes, vous pouvez écrire vous-même des méthodes de sérialisation. De cette façon, vous aurez un minimum de frais généraux.

Exemple:

public class MyClass {

   public int Id { get; set; }
   public string Name { get; set; }

   public byte[] Serialize() {
      using (MemoryStream m = new MemoryStream()) {
         using (BinaryWriter writer = new BinaryWriter(m)) {
            writer.Write(Id);
            writer.Write(Name);
         }
         return m.ToArray();
      }
   }

   public static MyClass Desserialize(byte[] data) {
      MyClass result = new MyClass();
      using (MemoryStream m = new MemoryStream(data)) {
         using (BinaryReader reader = new BinaryReader(m)) {
            result.Id = reader.ReadInt32();
            result.Name = reader.ReadString();
         }
      }
      return result;
   }

}

Eh bien un casting de myObjectpour byte[]ne va jamais au travail à moins que vous avez une conversion explicite ou si myObject est un byte[]. Vous avez besoin d'un cadre de sérialisation quelconque . Il y en a beaucoup là-bas, y compris les tampons de protocole qui me sont chers. C'est assez «mince et méchant» en termes d'espace et de temps.

Vous constaterez que presque tous les frameworks de sérialisation ont des restrictions importantes sur ce que vous pouvez sérialiser, cependant - les tampons de protocole plus que certains, en raison du fait qu'ils sont multiplateformes.

Si vous pouvez donner plus d'exigences, nous pouvons vous aider davantage - mais ce ne sera jamais aussi simple que de lancer ...

EDIT: Juste pour répondre à ceci:

J'ai besoin de mon fichier binaire pour contenir les octets de l'objet. Seuls les octets, pas de métadonnées du tout. Objet à objet emballé. Je vais donc implémenter la sérialisation personnalisée.

Veuillez garder à l'esprit que les octets de vos objets sont assez souvent des références ... vous devrez donc déterminer quoi faire avec eux.

Je soupçonne que vous constaterez que la conception et la mise en œuvre de votre propre cadre de sérialisation personnalisé sont plus difficiles que vous ne l'imaginez.

Je recommanderais personnellement que si vous ne devez le faire que pour quelques types spécifiques, vous ne vous souciez pas d'essayer de créer un cadre de sérialisation général. Implémentez simplement une méthode d'instance et une méthode statique dans tous les types dont vous avez besoin:

public void WriteTo(Stream stream)
public static WhateverType ReadFrom(Stream stream)

Une chose à garder à l'esprit: tout devient plus délicat si l'héritage est impliqué. Sans héritage, si vous savez par quel type vous commencez, vous n'avez pas besoin d'inclure d'informations de type. Bien sûr, il y a aussi la question du versionnage - avez-vous besoin de vous soucier de la compatibilité ascendante et descendante avec différentes versions de vos types?

J'ai pris la réponse de Crystalonics et les ai transformées en méthodes d'extension. J'espère que quelqu'un d'autre les trouvera utiles:

public static byte[] SerializeToByteArray(this object obj)
{
    if (obj == null)
    {
        return null;
    }
    var bf = new BinaryFormatter();
    using (var ms = new MemoryStream())
    {
        bf.Serialize(ms, obj);
        return ms.ToArray();
    }
}

public static T Deserialize<T>(this byte[] byteArray) where T : class
{
    if (byteArray == null)
    {
        return null;
    }
    using (var memStream = new MemoryStream())
    {
        var binForm = new BinaryFormatter();
        memStream.Write(byteArray, 0, byteArray.Length);
        memStream.Seek(0, SeekOrigin.Begin);
        var obj = (T)binForm.Deserialize(memStream);
        return obj;
    }
}

Vous parlez vraiment de sérialisation, qui peut prendre de nombreuses formes. Puisque vous voulez des petits et des binaires, les tampons de protocole peuvent être une option viable - offrant également une tolérance de version et une portabilité. À la différence BinaryFormatter, le format de fil des tampons de protocole n'inclut pas toutes les métadonnées de type; juste des marqueurs très laconiques pour identifier les données.

Dans .NET, il existe quelques implémentations; en particulier

• protobuf-net
• dotnet-protobufs

Je soutiendrais humblement que protobuf-net (que j'ai écrit) permet une utilisation plus idiomatique de .NET avec des classes C # typiques (les tampons de protocole "normaux" ont tendance à exiger la génération de code); par exemple:

[ProtoContract]
public class Person {
   [ProtoMember(1)]
   public int Id {get;set;}
   [ProtoMember(2)]
   public string Name {get;set;}
}
....
Person person = new Person { Id = 123, Name = "abc" };
Serializer.Serialize(destStream, person);
...
Person anotherPerson = Serializer.Deserialize<Person>(sourceStream);

Cela a fonctionné pour moi:

byte[] bfoo = (byte[])foo;

foo est un objet dont je suis sûr à 100% qui est un tableau d'octets.

Jetez un œil à la sérialisation , une technique pour «convertir» un objet entier en un flux d'octets. Vous pouvez l'envoyer au réseau ou l'écrire dans un fichier, puis le restaurer ultérieurement dans un objet.

J'ai trouvé un autre moyen de convertir un objet en octet [], voici ma solution:

IEnumerable en = (IEnumerable) myObject;
byte[] myBytes = en.OfType<byte>().ToArray();

Cordialement

Pour accéder directement à la mémoire d'un objet (pour faire un "core dump"), vous devrez vous diriger vers un code non sécurisé.

Si vous voulez quelque chose de plus compact que BinaryWriter ou qu'un vidage de la mémoire brute vous le donnera, vous devez écrire un code de sérialisation personnalisé qui extrait les informations critiques de l'objet et les emballe de manière optimale.

edit PS Il est très facile d'envelopper l'approche BinaryWriter dans un DeflateStream pour compresser les données, ce qui réduit généralement de moitié la taille des données.

Je crois que ce que vous essayez de faire est impossible.

Le courrier indésirable qui BinaryFormattercrée est nécessaire pour récupérer l'objet à partir du fichier après l'arrêt de votre programme.
Cependant, il est possible d'obtenir les données de l'objet, il vous suffit de connaître la taille exacte de celui-ci (plus difficile qu'il n'y paraît):

public static unsafe byte[] Binarize(object obj, int size)
{
    var r = new byte[size];
    var rf = __makeref(obj);
    var a = **(IntPtr**)(&rf);
    Marshal.Copy(a, r, 0, size);
    return res;
}

cela peut être récupéré via:

public unsafe static dynamic ToObject(byte[] bytes)
{
    var rf = __makeref(bytes);
    **(int**)(&rf) += 8;
    return GCHandle.Alloc(bytes).Target;
}

La raison pour laquelle les méthodes ci-dessus ne fonctionnent pas pour la sérialisation est que les quatre premiers octets des données renvoyées correspondent à un RuntimeTypeHandle. Le RuntimeTypeHandledécrit la disposition / le type de l'objet mais la valeur de celui-ci change à chaque exécution du programme.

EDIT: c'est stupide, ne faites pas ça -> Si vous connaissez déjà le type de l'objet à désérialiser avec certitude, vous pouvez changer ces octets BitConvertes.GetBytes((int)typeof(yourtype).TypeHandle.Value)au moment de la désérialisation.