C# Pourquoi ne pas “Vider” force les octets vers le bas le flux réseau?

La version courte est apparemment, lors de l'utilisation de XmlSerializer (ou tout autre gros blob) pour pousser données NetworkStream, il sera tout simplement tenir la ligne ouverte indéfiniment en attente pour plus d'informations écrites. Il ne bouffées de la connexion une fois que vous le fermez. Cela crée une situation où cette méthode est idéal pour l'envoi, mais pas de réception. Ou vice-versa. Il devient un moyen de communication, et inutile pour la suite de va-et-vient de la communication sur la même connexion.

C'est le genre de merde que j'ai eu à travailler autour de quelque chose qui semble si élégante sur la surface, mais de revenir à mon ancien C jours, j'ai eu recours à l'envoi d'un "nombre d'octets" paquets d'abord, puis les effectifs des paquets. Cela me permet de LIRE à l'autre extrémité, le nombre exact d'octets donc je n'ai jamais pris dans une situation de blocage.

À simplifier ma vie, j'ai créé une classe qui détient quelques méthodes statiques pour l'envoi et de la réception. Cette classe permet d'envoyer un XML-classe sérialisable sur le réseau, donc c'est ce que j'en ai besoin pour le faire.

Si quelqu'un a une solution plus élégante, je serais à l'écoute.

public class PacketTransit
{
public static void SendPacket(TcpClient C, object Packet)
{
MemoryStream ms = new MemoryStream();
XmlSerializer xml = new XmlSerializer(Packet.GetType());
xml.Serialize(ms, Packet);
ms.Position = 0;
byte[] b = ms.GetBuffer();
ms.Dispose();
byte [] sizePacket = BitConverter.GetBytes(b.Length);
//Send the 4-byte size packet first.
C.Client.Send(sizePacket, sizePacket.Length, SocketFlags.None);
C.Client.Send(b, b.Length, SocketFlags.None);
}
///The string is the XML file that needs to be converted.
public static string ReceivePacket(TcpClient C, Type PacketType)
{
byte [] FirstTen = new byte[1024];
int size = 0;
byte[] sizePacket = BitConverter.GetBytes(size);
//Get the size packet
int sp = C.Client.Receive(sizePacket, sizePacket.Length, SocketFlags.None);
if (sp <= 0) return "";
size = BitConverter.ToInt32(sizePacket, 0);
//read until "size" is met
StringBuilder sb = new StringBuilder();
while (size > 0)
{
byte[] b = new byte[1024];
int x = size;
if (x > 1024) x = 1024;
int r = C.Client.Receive(b, x, SocketFlags.None);
size -= r;
sb.Append(UTF8Encoding.UTF8.GetString(b));
}
return sb.ToString();
}
///The XML data that needs to be converted back to the appropriate type.
public static object Decode(string PacketData, Type PacketType)
{
MemoryStream ms = new MemoryStream(UTF8Encoding.UTF8.GetBytes(PacketData));
XmlSerializer xml = new XmlSerializer(PacketType);
object obj = xml.Deserialize(ms);
ms.Dispose();
return obj;
}
public static RequestPacket GetRequestPacket(TcpClient C)
{
string str = ReceivePacket(C, typeof(RequestPacket));
if (str == "") return new RequestPacket();
RequestPacket req = (RequestPacket) Decode(str, typeof(RequestPacket));
return req;
}
public static ResponsePacket GetResponsePacket(TcpClient C)
{
string str = ReceivePacket(C, typeof(ResponsePacket));
if (str == "") return new ResponsePacket();
ResponsePacket res = (ResponsePacket)Decode(str, typeof(ResponsePacket));
return res;
}
}

L'utilisation de cette classe, j'ai tout simplement besoin d'appeler PacketTransit.SendPacket(myTcpClient, SomePacket) pour envoyer toute donnée XML-objet Sérialisable. Je peux alors utiliser PacketTransit.GetResponsePacket ou PacketTransit.GetRequestPacket de le recevoir à l'autre extrémité.

Pour moi, cela fonctionne très bien, mais il était beaucoup plus d'une séance d'entraînement que prévu à l'origine.

OriginalL'auteur Jerry

Je crois que le vrai problème ici, peut être que le XmlDeserializer ne peut pas revenir jusqu'à ce qu'il a lu EOS à partir du flux. Vous devrez peut-être l'arrêt de l'envoi de flux de sortie à force de ce faire.

OriginalL'auteur user207421