Au hasard “Une connexion existante a dû être fermée par l'hôte distant.” après une réinitialisation TCP

J'ai deux pièces, un client et un serveur. Et j'essaie d'envoyer des données (taille > 5840 Octets) à partir du client vers le serveur, puis le serveur envoie les données en arrière. Je boucle ce un certain nombre de temps d'attente d'une seconde entre chaque temps. Parfois, le serveur crash de l'application, l'accident semble très aléatoire de l'erreur:

Exception Non Gérée: System.IO.IOException: Impossible de lire les données de la connexion de transport: Une connexion existante a dû être fermée par l'hôte distant. --->

Système.Net.Les Sockets.Exception socketexception: Une connexion existante a dû être fermée par l'hôte distant

au Système.Net.Les Sockets.Socket.Recevoir(Byte[] buffer, Int32 offset, taille Int32, SocketFlags socketFlags)

au Système.Net.Les Sockets.NetworkStream.Read(Byte[] buffer, Int32 décalage, Int32 s
ize)

--- Fin de l'exception interne trace de la pile ---

au Système.Net.Les Sockets.NetworkStream.Read(Byte[] buffer, Int32 décalage, Int32 s
ize)

à TCP_Server.Programme.Main(String[] args)

Code Client (C'est à l'intérieur de la boucle):

            try
            {
                Int32 port = 13777;
                using (TcpClient client = new TcpClient(ip, port))
                using (NetworkStream stream = client.GetStream())
                {
                    client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
                    var data = GenerateData(size);

                    sw.Start();
                    //Send the message to the connected TcpServer. 
                    stream.Write(data, 0, data.Length);

                    //Buffer to store the response bytes.
                    data = new Byte[size];

                    //Read the first batch of the TcpServer response bytes.
                    Int32 bytes = stream.Read(data, 0, data.Length);

                    sw.Stop();
                    Console.WriteLine(i + ": Done transporting " + size + " bytes to and from " + ip + " time: " +
                                      sw.ElapsedMilliseconds + " ms");
                    //Close everything.
                    stream.Close();
                    client.Close();
                }

            }
            catch (ArgumentNullException e)
            {
                Console.WriteLine("ArgumentNullException: {0}", e);
            }
            catch (SocketException e)
            {
                Console.WriteLine("SocketException: {0}", e);
            }

            sw.Reset();

Code serveur:

            Byte[] bytes = new Byte[size];

            //Enter the listening loop. 
            for (int i = 0; i < numberOfPackages; i++)
            {
                using (TcpClient client = server.AcceptTcpClient())
                using (NetworkStream stream = client.GetStream())
                {
                    client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
                    //Loop to receive all the data sent by the client. 
                    while ((stream.Read(bytes, 0, bytes.Length)) != 0)
                    {
                        //Send back a response.
                        stream.Write(bytes, 0, size);

                    }
                    client.GetStream().Close();
                    client.Close();
                }


                Console.WriteLine("Receive data size " + size);

            }

J'ai utilisé wireshark pour surveiller le tcp des paquets envoyés et a constaté qu'un paquet TCP RST est envoyé par le client au serveur avant que le programme se bloque. Donc je suppose que le problème est que le premier n'est pas de poignées correctement.
Il n'y a pas de pare-feu entre le client et l'hôte qui n'est pas le problème.

La wireshark fichiers pour le Client et le Serveur est ici: https://www.dropbox.com/sh/ctl2chq3y2c20n7/AACgIJ8IRiclqnyOyw8sqd9La?dl=0

Donc, soit j'ai besoin de se débarrasser de la TCP RST ou j'ai besoin de mon serveur pour gérer d'une certaine façon et pas de plantage.

J'ai essayé d'utiliser plus de temps d'attente, mais ça n'aide pas.
Si les données ci-dessous 5840 Octets je ne reçois pas tout les crashs, ce que je sais de la.

Des suggestions ou des idées?

EDIT:
Merci pour les réponses que j'ai eu à travailler avec les modifications suivantes:

Serveur:

//Loop to receive all the data sent by the client.
int k = 0;
while (k < size)
{
   int bytesRead = stream.Read(bytes, 0, bytes.Length);
   k += bytesRead;
}
//Send back a response.
stream.Write(bytes, 0, size);

Et même lors de la réception sur le côté client. Depuis que je tiens d'abord à envoyer toutes les données et de laisser le serveur de répondre cela fonctionne pour mon application.

OriginalL'auteur TobiasW | 2015-09-10