Ho controllato ma non riesco a vedere come serializzare direttamente una classe in un array di byte e successivamente deserializzare da un array di byte usando l'implementazione protobuf-net di Marc Gravell.Serializzazione/deserializzazione di Protobuf-net
Modifica: ho modificato la domanda e fornito il codice perché la domanda originale su come serializzare in byte [] senza dover passare attraverso il flusso era dichiaratamente banale. Mie scuse.
Domanda aggiornata: Esiste un modo per non avere a che fare con i generici e invece inferire il tipo di proprietà "MessageBody" attraverso il reflection quando viene passato attraverso il costruttore? Suppongo di non poter serializzare il tipo di oggetto, corretto? La soluzione attuale sembra molto complicata in quanto devo passare il tipo di MessageBody ogni volta che istanziato un nuovo messaggio. C'è una soluzione più sottile a questo?
mi si avvicinò con il seguente:
class Program
{
static void Main(string[] args)
{
Message<string> msg = new Message<string>("Producer", "Consumer", "Test Message");
byte[] byteArray = msg.Serialize();
Message<string> message = Message<string>.Deserialize(byteArray);
Console.WriteLine("Output");
Console.WriteLine(message.From);
Console.WriteLine(message.To);
Console.WriteLine(message.MessageBody);
Console.ReadLine();
}
}
[ProtoContract]
public class Message<T>
{
[ProtoMember(1)]
public string From { get; private set; }
[ProtoMember(2)]
public string To { get; private set; }
[ProtoMember(3)]
public T MessageBody { get; private set; }
public Message()
{
}
public Message(string from, string to, T messageBody)
{
this.From = from;
this.To = to;
this.MessageBody = messageBody;
}
public byte[] Serialize()
{
byte[] msgOut;
using (var stream = new MemoryStream())
{
Serializer.Serialize(stream, this);
msgOut = stream.GetBuffer();
}
return msgOut;
}
public static Message<T> Deserialize(byte[] message)
{
Message<T> msgOut;
using (var stream = new MemoryStream(message))
{
msgOut = Serializer.Deserialize<Message<T>>(stream);
}
return msgOut;
}
}
Quello che mi piace per arrivare a qualcosa come:
Messaggio newMsg = new Message ("Produttore", "consumatore", Foo); byte [] byteArray = newMsg.Serialize();
e Messaggio msg = Message.Deserialize (byteArray);
(dove Deserialize è un metodo statico e deserializza sempre in un oggetto di tipo Message e deve solo conoscere il tipo di deserializzazione del corpo del messaggio in).
non è Protobuf.net open-source? –
È, ma non voglio regolare la sorgente perché mi piace stare al passo con le nuove versioni senza dover apportare modifiche successive perché la libreria è solo un componente molto piccolo come parte di progetti molto più grandi. –
Un 'MemoryStream' è solo una matrice di byte sotto mentite spoglie, qual è il problema di usarlo? –