Convertir n'importe quel objet à un byte[]

Utiliser 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();
    }
}

Noter que obj et les propriétés des champs dans obj (et donc-pour l'ensemble de leurs propriétés, des champs) devront tous être marqués avec le Serializable l'attribut pour réussir à être sérialisé avec cette.

Comme d'autres l'ont dit avant, vous pouvez utiliser la sérialisation binaire, mais elle peut produire une octets supplémentaires ou être désérialisée dans un des objets ayant pas exactement les mêmes données. L'utilisation de la réflexion sur l'autre main est assez compliqué et très lent.
Il y a une autre solution qui peut strictement convertir vos objets d'octets et vice-versa - ordonnancement:

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 de convertir des octets de l'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);

C'est nettement plus lent et en partie impropre à l'utilisation de cette approche pour les petits objets et les structures de comparer à votre propre sérialisation champ par champ (à cause du double de la copie de/vers la mémoire non gérée), mais il est facile d'strictement convertit l'objet en byte[] sans la mise en œuvre de la sérialisation et sans attribut [Serializable].

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 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'aide de Encoding.UTF8.GetBytes est plus rapide que l'utilisation MemoryStram.
Ici, je suis en utilisant NewtonsoftJson pour convertir les données d'entrée de l'objet à chaîne JSON et l'obtention d'octets à partir de chaîne JSON.

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

De référence pour @Daniel DiPaolo version 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 |

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

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

Je préfère utiliser l'expression "sérialisation" que "moulage en octets". La sérialisation d'un objet signifie de le convertir en un tableau d'octets (ou XML, ou autre chose) qui peut être utilisé sur la télécommande de la boîte à re-construire l'objet. Dans .NET, le Serializable l'attribut marques types dont les objets peuvent être sérialisés.

Comment sur la sérialisation? jetez un oeil ici.