Warum blockiert der Server beim Laden von XML von einem NetworkStream?

Question

Ich habe einen einfachen Client und Server in C#. Das Ziel besteht darin, dass der Client ein XML-Dokument an den Server sendet und der Server dann mit einem anderen XML-Dokument antworten sollte. Der Server blockiert, wenn ich versuche, die Eingabe-/Anfrage-XML mit XmlDocument.Load (NetworkStream) zu empfangen.

Server:

 TcpListener t = new TcpListener(IPAddress.Any, 4444); 
     t.Start(); 
     TcpClient c = t.AcceptTcpClient(); 
     NetworkStream s = c.GetStream(); 
     XmlDocument req = new XmlDocument(); 
     req.Load(s); 

     string respString = "<response><data>17</data></response>"; 
     XmlDocument resp = new XmlDocument(); 
     resp.LoadXml(respString); 
     resp.Save(s); 

Auftraggeber:

 TcpClient t = new TcpClient("localhost", 4444); 
     NetworkStream s = t.GetStream(); 

     string reqStr = "<request><parameters><param>7</param><param>15</param></parameters></request>"; 
     XmlDocument req = new XmlDocument(); 
     req.LoadXml(reqStr); 

     req.Save(s); 

     XmlDocument resp = new XmlDocument(); 
     resp.Load(s); 

     Console.WriteLine(resp.OuterXml); 

Ich habe versucht, einen Flush() in dem Client hinzugefügt, nachdem er die Anfrage XmlDocument zum Strom spart, aber das schien nicht zu helfen . Ursprünglich versuchte ich, den Server alle Eingaben vom Client zu einem MemoryStream lesen zu lassen, aber dann stellte ich fest, dass es keine Möglichkeit gab, dem Server zu signalisieren, dass alle Eingaben ohne Trennung gemacht wurden, was dann der Client nicht konnte lies seine Eingabe.

Ich kann XML-Eingabe an den Server aus einer Datei mit Netcat und alles funktioniert gut. Das funktioniert, ob ich XmlDocument.Load (NetworkStream) auf dem Server verwende oder alle Eingaben in einen MemoryStream lese. Was macht Netcat in diesem Fall, den ich in meinem C# -Client nicht mache, und wie mache ich das in C#? Sollte ich das anders machen?

Answer 1

Die TCP-Verbindung ist bidirektional und Sie können die Hälfte davon schließen, während die andere Hälfte noch offen ist. In diesem Fall können Sie die Client-Server-Hälfte nach dem Senden aller Daten schließen, und dann können Sie die Antwort über den Server an die Client-Hälfte erhalten. Sie können es so für Ihr Beispiel tun:

TcpClient t = new TcpClient("localhost", 4444); 
NetworkStream s = t.GetStream(); 
string reqStr = "<request><parameters><param>7</param><param>15</param></parameters></request>"; 
XmlDocument req = new XmlDocument(); 
req.LoadXml(reqStr); 
req.Save(s); 
// important line here! shutdown "send" half of the socket connection. 
t.Client.Shutdown(SocketShutdown.Send); 
XmlDocument resp = new XmlDocument(); 
resp.Load(s); 
Console.WriteLine(resp.OuterXml); 

Vergessen Sie nicht, Netzwerk-Stream auf einem Server Seite verfügen, nachdem Sie alle Daten gesendet:

Eigentlich

TcpListener t = new TcpListener(IPAddress.Loopback, 4444); 
t.Start(); 
TcpClient c = t.AcceptTcpClient(); 
using (NetworkStream s = c.GetStream()) { 
    XmlDocument req = new XmlDocument(); 
    req.Load(s);     
    Console.WriteLine("Got request: {0}", req.OuterXml); 
    string respString = "<response><data>17</data></response>"; 
    XmlDocument resp = new XmlDocument(); 
    resp.LoadXml(respString); 
    resp.Save(s); 
} 

wenn ganze Kommunikation durch einzelne Anforderung folgt Einzelantwort - Sie können diese Technik anstelle von benutzerdefinierten Protokollen über TCP verwenden (denken Sie daran, Timeouts zu verwenden und Ihre Streams und TCP-Clients ordnungsgemäß zu entsorgen).

Andernfalls denken Sie daran, dass Netzwerk-Stream eine Art offene Verbindung zwischen Client und Server ist - es hat kein explizites "Ende". Wenn Sie XmlDocument.Load tun - es wird gelesen, bis es möglich ist (das heißt, bis Read mit 0 Byte gelesen wird), so blockiert es in Ihrem Fall. Sie sollten Ihr eigenes Protokoll über TCP definieren, damit Sie selbst die Nachrichtengrenze definieren können. Einfacher Weg wäre - die ersten 4 Bytes definieren die Länge der folgenden Nachricht. Sie lesen also die ersten 4 Bytes und lesen dann, bis diese Länge erreicht ist oder ein Timeout auftritt.