J'écris un prototype de connexion TCP et j'ai du mal à homogénéiser les données à envoyer.

Pour le moment, je n'envoie que des chaînes, mais à l'avenir nous voulons pouvoir envoyer n'importe quel objet.

Le code est assez simple pour le moment, car je pensais que tout pouvait être converti dans un tableau d'octets:

void SendData(object headerObject, object bodyObject)
{
  byte[] header = (byte[])headerObject;  //strings at runtime, 
  byte[] body = (byte[])bodyObject;      //invalid cast exception

  // Unable to cast object of type 'System.String' to type 'System.Byte[]'.
  ...
}

Ceci est bien sûr assez facilement résolu avec un

if( state.headerObject is System.String ){...}

Le problème est que si je le fais de cette façon, je dois vérifier CHAQUE type d'objet qui ne peut pas être converti en octet [] lors de l'exécution.

Puisque je ne connais pas tous les objets qui ne peuvent pas être convertis en octet [] à l'exécution, ce n'est vraiment pas une option.

Comment convertir n'importe quel objet en un tableau d'octets en C # .NET 4.0?

Utilisez le BinaryFormatter:

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

Notez que objtoutes les propriétés / champs dans obj(et ainsi de suite pour toutes leurs propriétés / champs) devront tous être étiquetés avec l' Serializableattribut pour être sérialisés avec cela.

consultez cet article: http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html

Utilisez le code ci-dessous

// Convert an object to a byte array
private byte[] ObjectToByteArray(Object obj)
{
    if(obj == null)
        return null;

    BinaryFormatter bf = new BinaryFormatter();
    MemoryStream ms = new MemoryStream();
    bf.Serialize(ms, obj);

    return ms.ToArray();
}

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

    return obj;
}

Comme d'autres l'ont déjà dit, vous pouvez utiliser la sérialisation binaire, mais cela peut produire des octets supplémentaires ou être désérialisé en objets avec pas exactement les mêmes données. Utiliser la réflexion par contre est assez compliqué et très lent. Il existe une autre solution qui permet de convertir strictement vos objets en octets et vice-versa - le marshalling:

var size = Marshal.SizeOf(your_object);
// Both managed and unmanaged buffers required.
var bytes = new byte[size];
var ptr = Marshal.AllocHGlobal(size);
// Copy object byte-to-byte to unmanaged memory.
Marshal.StructureToPtr(your_object, ptr, false);
// Copy data from unmanaged memory to managed buffer.
Marshal.Copy(ptr, bytes, 0, size);
// Release unmanaged memory.
Marshal.FreeHGlobal(ptr);

Et pour convertir des octets en objet:

var bytes = new byte[size];
var ptr = Marshal.AllocHGlobal(size);
Marshal.Copy(bytes, 0, ptr, size);
var your_object = (YourType)Marshal.PtrToStructure(ptr, typeof(YourType));
Marshal.FreeHGlobal(ptr);

Il est nettement plus lent et en partie dangereux d'utiliser cette approche pour les petits objets et structures par rapport à votre propre champ de sérialisation par champ (en raison de la double copie de / vers la mémoire non gérée), mais c'est le moyen le plus simple de convertir strictement l'objet en octet [] sans implémenter la sérialisation et sans attribut [Serializable].

Ce que vous recherchez, c'est la sérialisation. Il existe plusieurs formes de sérialisation disponibles pour la plateforme .Net

• Sérialisation binaire
• Sérialisation XML: produit une chaîne facilement convertible en byte[]
• ProtoBuffers

public static class SerializerDeserializerExtensions
{
    public static byte[] Serializer(this object _object)
    {   
        byte[] bytes;
        using (var _MemoryStream = new MemoryStream())
        {
            IFormatter _BinaryFormatter = new BinaryFormatter();
            _BinaryFormatter.Serialize(_MemoryStream, _object);
            bytes = _MemoryStream.ToArray();
        }
        return bytes;
    }

    public static T Deserializer<T>(this byte[] _byteArray)
    {   
        T ReturnValue;
        using (var _MemoryStream = new MemoryStream(_byteArray))
        {
            IFormatter _BinaryFormatter = new BinaryFormatter();
            ReturnValue = (T)_BinaryFormatter.Deserialize(_MemoryStream);    
        }
        return ReturnValue;
    }
}

Vous pouvez l'utiliser comme le code ci-dessous.

DataTable _DataTable = new DataTable();
_DataTable.Columns.Add(new DataColumn("Col1"));
_DataTable.Columns.Add(new DataColumn("Col2"));
_DataTable.Columns.Add(new DataColumn("Col3"));

for (int i = 0; i < 10; i++) {
    DataRow _DataRow = _DataTable.NewRow();
    _DataRow["Col1"] = (i + 1) + "Column 1";
    _DataRow["Col2"] = (i + 1) + "Column 2";
    _DataRow["Col3"] = (i + 1) + "Column 3";
    _DataTable.Rows.Add(_DataRow);
}

byte[] ByteArrayTest =  _DataTable.Serializer();
DataTable dt = ByteArrayTest.Deserializer<DataTable>();

L'utilisation Encoding.UTF8.GetBytesest plus rapide que l'utilisation MemoryStream. Ici, j'utilise NewtonsoftJson pour convertir l'objet d'entrée en chaîne JSON, puis j'obtiens les octets de la chaîne JSON.

byte[] SerializeObject(object value) =>Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(value));

Benchmark pour la version de @Daniel DiPaolo avec cette version

Method                    |     Mean |     Error |    StdDev |   Median |  Gen 0 | Allocated |
--------------------------|----------|-----------|-----------|----------|--------|-----------| 
ObjectToByteArray         | 4.983 us | 0.1183 us | 0.2622 us | 4.887 us | 0.9460 |    3.9 KB |
ObjectToByteArrayWithJson | 1.548 us | 0.0309 us | 0.0690 us | 1.528 us | 0.3090 |   1.27 KB |

Solutions combinées dans la classe Extensions:

public static class Extensions {

    public static byte[] ToByteArray(this object obj) {
        var size = Marshal.SizeOf(data);
        var bytes = new byte[size];
        var ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(data, ptr, false);
        Marshal.Copy(ptr, bytes, 0, size);
        Marshal.FreeHGlobal(ptr);
        return bytes;
   }

    public static string Serialize(this object obj) {
        return JsonConvert.SerializeObject(obj);
   }

}

Vous pouvez utiliser les outils de sérialisation intégrés dans le framework et sérialiser vers un MemoryStream . Cela peut être l'option la plus simple, mais peut produire un octet [] plus grand que ce qui peut être strictement nécessaire pour votre scénario.

Si tel est le cas, vous pouvez utiliser la réflexion pour parcourir les champs et / ou propriétés de l'objet à sérialiser et les écrire manuellement dans le MemoryStream, en appelant la sérialisation de manière récursive si nécessaire pour sérialiser des types non triviaux. Cette méthode est plus complexe et prendra plus de temps à implémenter, mais vous permet de mieux contrôler le flux sérialisé.

Que diriez-vous de quelque chose de simple comme ça?

return ((object[])value).Cast<byte>().ToArray(); 

Je préfère utiliser l'expression «sérialisation» plutôt que «transtypage en octets». Sérialiser un objet signifie le convertir en un tableau d'octets (ou XML, ou autre chose) qui peut être utilisé sur la boîte distante pour reconstruire l'objet. Dans .NET, l' Serializableattribut marque les types dont les objets peuvent être sérialisés.

Autre façon de convertir un objet en tableau d'octets:

TypeConverter objConverter = TypeDescriptor.GetConverter(objMsg.GetType());
byte[] data = (byte[])objConverter.ConvertTo(objMsg, typeof(byte[]));

Une implémentation supplémentaire, qui utilise le JSON binaire Newtonsoft.Json et ne nécessite pas de tout marquer avec l'attribut [Serializable]. Un seul inconvénient est qu'un objet doit être enveloppé dans une classe anonyme, donc le tableau d'octets obtenu avec la sérialisation binaire peut être différent de celui-ci.

public static byte[] ConvertToBytes(object obj)
{
    using (var ms = new MemoryStream())
    {
        using (var writer = new BsonWriter(ms))
        {
            var serializer = new JsonSerializer();
            serializer.Serialize(writer, new { Value = obj });
            return ms.ToArray();
        }
    }
}

La classe anonyme est utilisée car BSON doit commencer par une classe ou un tableau. Je n'ai pas essayé de désérialiser l'octet [] en objet et je ne suis pas sûr que cela fonctionne, mais j'ai testé la vitesse de conversion en octet [] et cela satisfait complètement mes besoins.

Et la sérialisation? jetez un oeil ici .