convert - byte[] c# example

C#y.NET: ¿Cómo serializar una estructura en una matriz de bytes[], usando BinaryWriter?

Question

¿Cómo serializar una estructura bastante compleja en un byte [] array, usando BinaryWriter?

Actualizar:

• Para que esto funcione, cada estructura (y subestructura?) Debe decorarse con el atributo [Serializable].

• No necesito implementar la interfaz ISerializable, ya que está diseñada para dar control a un objeto sobre su propia serialización.

Answer 1

Use el BinaryFormatter para serializar un objeto a un byte []. BinaryWriter es solo para escribir bytes en una secuencia.

MyObject obj = new MyObject();
byte[] bytes;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, obj);
bytes = stream.ToArray();
}

Answer 2

fragmento de código.

public static byte[] XmlSerializeToByte<T>(T value) where T : class
{
if (value == null)
{
throw new ArgumentNullException();
}
XmlSerializer serializer = new XmlSerializer(typeof(T));
using (MemoryStream memoryStream = new MemoryStream())
{
using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream))
{
serializer.Serialize(xmlWriter, value);
return memoryStream.ToArray();
}
}
}
public static T XmlDeserializeFromBytes<T> (byte[] bytes)
where T : class
{
if (bytes == null || bytes.Length == 0)
{
throw new InvalidOperationException();
}
XmlSerializer serializer = new XmlSerializer(typeof(T));
using (MemoryStream memoryStream = new MemoryStream(bytes))
{
using (XmlReader xmlReader = XmlReader.Create(memoryStream))
{
return (T)serializer.Deserialize(xmlReader);
}
}
}
//Serialize
Duck duck = new Duck() { Name = "Donald Duck" };
byte[] bytes = Test.XmlSerializeToByte(duck);
//Deserialize
var deDuck = Test.XmlDeserializeFromBytes<Duck>(bytes);
Console.WriteLine(deDuck.Name);

Answer 3

A partir de los comentarios, el escenario del OP requiere una gran compatibilidad con las futuras versiones de la aplicación / .NET, en cuyo caso siempre recomiendo de nuevo a BinaryFormatter : tiene muchas "características" que simplemente no funcionan bien entre versiones (y ciertamente no entre plataformas) .

Recomiendo mirar a los serializadores basados ​​en contrato; Estoy sesgado, pero me inclino por protobuf-net (que se corresponde con la especificación de protobuf de Google). La forma más fácil de hacer esto es atribuir los tipos de tal manera que la biblioteca pueda hacer que los trabajos sean más sencillos (aunque también se puede hacer sin atributos), por ejemplo:

 [ProtoContract]
public class Customer {
[ProtoMember(1)]
public List<Order> Orders {get {....}}
[ProtoMember(2)]
public string Name {get;set;}
... etc
}

(la asignación de atributo es muy familiar si ha realizado algún trabajo con XmlSerializer o DataContractSerializer, y de hecho, protobuf-net puede consumir los atributos de esos si no desea agregar atributos específicos de protobuf-net)

entonces algo como:

Customer cust = ...
byte[] data;
using(var ms = new MemoryStream()) {
Serializer.Serialize(ms, cust);
data = ms.ToArray();
}

Los datos producidos de esta manera son independientes de la plataforma y podrían cargarse en cualquier contrato coincidente (ni siquiera tiene que ser un Customer , podría ser de cualquier tipo con un diseño coincidente a través de los atributos). De hecho, en la mayoría de los casos se cargará fácilmente en cualquier otra implementación de protobuf: Java, C ++, etc.