serializacion - serializar objeto c# xml

C#TcpClient: ¿Enviar objetos serializados usando separadores?

Question

Basado en la serialización (mencionado aquí https://stackoverflow.com/a/7849374/985798 ) Estoy tratando de rediseñar mi pequeña aplicación tcp, que estaba utilizando un mensaje de cadena hasta ahora.

Pero me encontré con un pequeño problema y me gustaría saber qué solución me recomendaría usar:

Si intento enviar más de un mensaje en un intervalo muy pequeño, se fusionarán en la "cola" y el cliente recibirá ambos mensajes al mismo tiempo, que terminarán con un solo objeto roto. En el pasado resolví este problema con un separador de cadenas "| end |" y pude dividirlo y procesarlo en un ciclo foreach.

¿Es ese un buen enfoque? ¿Cómo resolverías ese problema en base a matrices de bytes de objetos serializados? ¿Utilizarías un delimitador de byte[] o usarías otra solución?

Answer 1

Aquí hay un ejemplo genérico para enviar objetos entre el cliente y el servidor usando Json.Net. Utiliza NewLine char como separador. Entonces, todo lo que necesita es crear StreamReader y StreamWriter a partir de flujos de red y usar los métodos ReadLine y WriteLine ....

(PD: Dado que Json.Net escapa de NewLine char en serialización, los mensajes que lo contienen no causan problemas ...)

void SendObject<T>(StreamWriter s, T o)
{
    s.WriteLine( JsonConvert.SerializeObject(o) );
    s.Flush();
}

T ReadObject<T>(StreamReader r)
{
    var line = r.ReadLine();
    if (line == null) return default(T);
    return JsonConvert.DeserializeObject<T>(line);
}

SemaphoreSlim serverReady = new SemaphoreSlim(0);
//SERVER
Task.Factory.StartNew(() =>
    {
        TcpListener listener = new TcpListener(IPAddress.Any, 8088);
        listener.Start();
        serverReady.Release();
        while(true)
        {
            var client = listener.AcceptTcpClient();
            Task.Factory.StartNew(() =>
                {
                    Console.WriteLine("Client connected...");
                    var reader = new StreamReader(client.GetStream());
                    var obj = ReadObject<string>( reader) ;
                    while(obj != null)
                    {
                        Console.WriteLine("[" + obj + "]");
                        obj = ReadObject<string>(reader);
                    }
                    Console.WriteLine("Client disconnected...");
                });
        }

    });


serverReady.Wait();
//CLIENT
Task.Factory.StartNew(() =>
{
    TcpClient client = new TcpClient();
    client.Connect("localhost", 8088);
    var writer = new StreamWriter(client.GetStream());
    for (int i = 0; i < 10; i++)
    {
        SendObject(writer, "test/nmessage" + i); //message containing `/n` :)
    }
    client.Close();
});

Answer 2

Ni siquiera debería necesitar un delimitador en su caso, todo lo que está tratando de hacer aquí es pasar un objeto en trozos. Recomendaría ir por algo un poco más ligero que la serialización XML, por ejemplo, JSON.

var objectJson = new JavaScriptSerializer().Serialize(myObject);

Esto le daría una cadena en el formato de

{
    "Member1": "Value",
    "Member2": [ "Value1", "Value2" ],
    ...etc
}

Todo lo que necesita hacer es seguir fusionando los trozos hasta que tenga un objeto completo y luego llame

var object = new JavaScriptSerializer().Deserialize<MyObject>(objectJson);

Por otro lado.