Estoy escribiendo un prototipo de conexión TCP y tengo problemas para homogeneizar los datos que se enviarán.

Por el momento, no estoy enviando nada más que cadenas, pero en el futuro queremos poder enviar cualquier objeto.

El código es bastante simple en este momento, porque pensé que todo podría convertirse en una matriz de bytes:

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[]'.
  ...
}

Por supuesto, esto se resuelve fácilmente con un

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

El problema es que, si lo hago de esa manera, necesito verificar CADA tipo de objeto que no se pueda convertir a un byte [] en tiempo de ejecución.

Como no conozco todos los objetos que no se pueden convertir en un byte [] en tiempo de ejecución, esto realmente no es una opción.

¿Cómo se convierte un objeto en una matriz de bytes en C # .NET 4.0?

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

Tenga en cuenta que objy todas las propiedades / campos dentro obj(y así sucesivamente para todas sus propiedades / campos) deberán etiquetarse con el Serializableatributo para ser serializados con éxito con esto.

consulte este artículo: http://www.morgantechspace.com/2013/08/convert-object-to-byte-array-and-vice.html

Usa el siguiente código

// 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;
}

Como otros han dicho antes, podría usar la serialización binaria, pero puede producir bytes adicionales o deserializarse en objetos con datos no exactamente iguales. Usar la reflexión por otro lado es bastante complicado y muy lento. Hay otra solución que puede convertir estrictamente sus objetos a bytes y viceversa: la clasificación:

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);

Y para convertir bytes en objeto:

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);

Es notablemente más lento y en parte inseguro utilizar este enfoque para objetos pequeños y estructuras en comparación con su propio campo de serialización por campo (debido a la doble copia desde / a la memoria no administrada), pero es la forma más fácil de convertir estrictamente el objeto en byte [] sin implementar la serialización y sin atributo [Serializable].

Lo que estás buscando es la serialización. Hay varias formas de serialización disponibles para la plataforma .Net

• Serialización binaria
• Serialización XML: produce una cadena que es fácilmente convertible en un 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;
    }
}

Puedes usarlo como el siguiente código.

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

Usar Encoding.UTF8.GetByteses más rápido que usar MemoryStream. Aquí, estoy usando NewtonsoftJson para convertir el objeto de entrada a una cadena JSON y luego obtengo bytes de la cadena JSON.

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

Punto de referencia para la versión de @Daniel DiPaolo con esta versión

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 |

Clase de soluciones combinadas en extensiones:

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

}

Puede utilizar las herramientas de serialización integradas en el marco y serializar en un MemoryStream . Esta puede ser la opción más sencilla, pero puede producir un byte más grande [] que el estrictamente necesario para su escenario.

Si ese es el caso, podría utilizar la reflexión para iterar sobre los campos y / o propiedades en el objeto a serializar y escribirlos manualmente en el MemoryStream, llamando a la serialización de forma recursiva si es necesario para serializar tipos no triviales. Este método es más complejo y llevará más tiempo implementarlo, pero le permite mucho más control sobre la secuencia serializada.

¿Qué tal algo simple como esto?

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

Prefiero usar la expresión "serialización" que "convertir en bytes". Serializar un objeto significa convertirlo en una matriz de bytes (o XML u otra cosa) que se pueda usar en el cuadro remoto para reconstruir el objeto. En .NET, el Serializableatributo marca tipos cuyos objetos se pueden serializar.

Manera alternativa de convertir objeto a matriz de bytes:

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

Una implementación adicional, que utiliza JSON binario Newtonsoft.Json y no requiere marcar todo con el atributo [Serializable]. Solo un inconveniente es que un objeto tiene que estar envuelto en una clase anónima, por lo que la matriz de bytes obtenida con la serialización binaria puede ser diferente de esta.

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 clase anónima se usa porque BSON debe comenzar con una clase o matriz. No he intentado deserializar el byte [] de vuelta al objeto y no estoy seguro de si funciona, pero he probado la velocidad de conversión al byte [] y satisface completamente mis necesidades.

¿Qué tal la serialización? Echa un vistazo aquí .