Dateien über TCP/IP

brekki · 16. Juli 2010

Hallo zusammen,

ich habe ein kleines Problem mit der Übertragung von Dateien via TCP/IP. Ich mir die angehängte Datei aus einem Post (http://www.tutorials.de/forum/net-a...ne-datei-zu-einem-programm-2.html#post1092721) als Vorlage genommen und wollte dann entsprechend weiter gehen und es mit dem umgekehrten Weg versuchen.

Also nicht: Client bietet Server Datei an und Server sagt "ja, die nehme ich" und der Upload wird freigegeben
Sondern: Client fordert Datei bei Server an, Server sagt "Passt scho" und der Download beginnt.

Mit dem Download an sich habe ich keine Probleme, nur der Beendigung des Stream. Da bleibt mit das Programm immer hängen. Habe jetzt zu lange auf den Quellcode geschaut und kann ihn nicht mehr fehlerneutral betrachten, eine neutrale Fehlerhilfe wäre mir sehr willkommen.

Hier ist der Code des Servers zum Senden der Datei (der Code läuft ohne Probleme durch, also das versenden der Datei wird einwandfrei beendet und er meldet mir auch nacher "successfully send"):

private void sendFile(NetworkStream stream, string filename)
{
FileStream fstream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
long s_length = fstream.Length;
long s_read = 0;

// Übertragen der Dateigröße zur Verarbeitung auf Client
//send(stream, "LENGTH " + s_length);

using (BinaryReader reader = new BinaryReader(fstream))
{
while (s_length > s_read)
{
byte[] buffer = new byte[1024];
int read = reader.Read(buffer, 0, 1024);
s_read += read;

sendBuffer(stream, buffer, read);

//int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

//if (pc % 5 == 0)
// Percentage = pc;
}
}
stream.Flush();
Console.WriteLine(DateTime.Now.ToLocalTime()
+ " '{0}' successfully send..", filename);
}

Hier der Code des Clients (Dateiübertragung einwandfrei, lässt sich auch öffnen - ich hatte eine Accessdatei zum testen übertragen) aber der stream wird nicht beendet):

public void LoadFile(string path, string file)
{
TcpClient client = new TcpClient();
client.Connect(m_server, m_port);
NetworkStream stream = client.GetStream();

sendMsg(stream, "GET " + file);
string msg = readMsg(stream);
string accept_msg = "OK " + file;

System.Diagnostics.Debug.WriteLine(string.Format("Ready '{0}' - Receiving '{1}'",
msg, accept_msg));

// Annahme der Dateigröße zur Verarbeitung für z. B. ProgressBar
//string length = readMsg(stream);
//long s_length = Convert.ToInt64(length.Substring(7, length.Length - 7));
//long s_read = 0;

if (msg.Equals(accept_msg))
{
using (BinaryWriter writer = new BinaryWriter(
File.Create(Path.Combine(path, file))))
{
while (true)
{
byte[] buffer = new byte[1024];
int read = stream.Read(buffer, 0, 1024);
writer.Write(buffer, 0, read);
if (read == 0)
break;

// Verarbeiten der Dateigröße für z. B. ProgressBar
//s_read += read;
//int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

//if (pc % 5 == 0)
// Percentage = pc;
}
}

System.Diagnostics.Debug.WriteLine(DateTime.Now.ToShortDateString()
+ DateTime.Now.ToShortTimeString()
+ string.Format(" '{0}' successfully written..", Path.Combine(path, file)));
}
else
System.Diagnostics.Debug.WriteLine(
string.Format("File not accepted by server..."));

stream.Close();
client.Close();

System.Diagnostics.Debug.WriteLine(string.Format("Exit..."));
}

Der Client ist ein Windows Form. Wenn der Download beendet ist (das sieht man ja im Explorer), bleibt die Client Routine immer in der Zeile "writer.Write(buffer, 0, read);" hängen und springt erst garnicht zu "successfully written", während auf dem Server die Funktion richtig durchläuft und er Erfolg vermeldet.

Kann mir da jemand mit neutralem Auge helfen?

Viele Grüße
Sebastian

Steiner_B · 19. Juli 2010

So mal das ganze in Codeblöcken, damit man sieht was passiert:

Servercode:

C#:

private void sendFile(NetworkStream stream, string filename)
{
FileStream fstream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
long s_length = fstream.Length;
long s_read = 0;

// Übertragen der Dateigröße zur Verarbeitung auf Client
//send(stream, "LENGTH " + s_length);

using (BinaryReader reader = new BinaryReader(fstream))
{
while (s_length > s_read)
{
byte[] buffer = new byte[1024];
int read = reader.Read(buffer, 0, 1024);
s_read += read;

sendBuffer(stream, buffer, read);

//int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

//if (pc % 5 == 0)
// Percentage = pc;
}
}
stream.Flush();
Console.WriteLine(DateTime.Now.ToLocalTime()
+ " '{0}' successfully send..", filename);
}

Clientcode:

C#:

public void LoadFile(string path, string file)
{
TcpClient client = new TcpClient();
client.Connect(m_server, m_port);
NetworkStream stream = client.GetStream();

sendMsg(stream, "GET " + file);
string msg = readMsg(stream);
string accept_msg = "OK " + file;

System.Diagnostics.Debug.WriteLine(string.Format("Ready '{0}' - Receiving '{1}'",
msg, accept_msg));

// Annahme der Dateigröße zur Verarbeitung für z. B. ProgressBar
//string length = readMsg(stream);
//long s_length = Convert.ToInt64(length.Substring(7, length.Length - 7));
//long s_read = 0;

if (msg.Equals(accept_msg))
{
using (BinaryWriter writer = new BinaryWriter(
File.Create(Path.Combine(path, file))))
{
while (true)
{
byte[] buffer = new byte[1024];
int read = stream.Read(buffer, 0, 1024);
writer.Write(buffer, 0, read);
if (read == 0)
break;

// Verarbeiten der Dateigröße für z. B. ProgressBar
//s_read += read;
//int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

//if (pc % 5 == 0)
// Percentage = pc;
}
}

System.Diagnostics.Debug.WriteLine(DateTime.Now.ToShortDateString()
+ DateTime.Now.ToShortTimeString()
+ string.Format(" '{0}' successfully written..", Path.Combine(path, file)));
}
else
System.Diagnostics.Debug.WriteLine(
string.Format("File not accepted by server..."));

stream.Close();
client.Close();

System.Diagnostics.Debug.WriteLine(string.Format("Exit..."));
}

Steiner_B · 19. Juli 2010

Dein Problem liegt in der Verwendung der NetworkStreams:

Zitat aus der MSDN-Seite:

Use the Write and Read methods for simple single thread synchronous blocking I/O

Wichtig ist hier das "blocking". Deine Read-Operation wartet solange bis Daten ankommen. Wenn keine Daten mehr kommen wartet sie immer weiter. Zusätzlich dazu schließt du am Server auch den Stream nicht.

Lösung: siehe MSDN http://msdn.microsoft.com/en-us/library/system.net.sockets.networkstream.read.aspx

brekki · 19. Juli 2010

Guten Morgen,

Danke für die Antwort. An den Funktionen an sich kann nicht viel falsches sein. Der umgekehrte Weg funktioniert, also Datei-von-Client-zu-Server. Es sind dieselben Funktionen, nur der Weg Datei-von-Server-zu-Client will nicht. Für den Upload wird der Networkstream auch nicht geschlossen, sondern nur geflushed. Der Networkstream wird auch noch benötigt für eventuelle Kommandos an den Server. Ich wunder mich, warum es in die eine Richtung klappt, in die andere jedoch nicht.

Hier mal der komplette ServerCode

Code:

class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Close the Window to terminate..\r\n");

                FileReceiver receiver = new FileReceiver();
                receiver.Start();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }

class FileReceiver
    {
        string data_dir;
        
        TcpListener listener;

        public FileReceiver()
        {
            data_dir = @"G:\Data";

            if (!Directory.Exists(data_dir))
            {
                Directory.CreateDirectory(data_dir);
            }
            
            Console.WriteLine("Storing Data in '{0}'", data_dir);

            IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());

            Console.WriteLine("Using '{0}' as IPAddress", hostEntry.AddressList[0].ToString());
            listener = new TcpListener(hostEntry.AddressList[0], 5990);
        }

        public void Start()
        {
            try
            {
                listener.Start();

                while (!listener.Pending())
                {
                    TcpClient client = listener.AcceptTcpClient();
                    handleClient(client);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public void Stop()
        {
            listener.Stop();
        }

        //---

        private void handleClient(TcpClient client)
        {
            NetworkStream stream = client.GetStream();
            Encoding enc = Encoding.UTF8;

            while (true)
            {
                byte[] buffer = new byte[1024];
                int read = stream.Read(buffer, 0, 1024);

                if (read == 0)
                    break;

                string cmd = enc.GetString(buffer, 0, read);

                if (cmd.StartsWith("SET "))
                {
                    // Datei von Server zu Client
                    string file = cmd.Substring(4, cmd.Length - 4);
                    file = file.Trim(new char[] { '\r', '\n' });

                    Console.WriteLine(DateTime.Now.ToLocalTime() + " '{0}' offered. Accept? [n] ", file);

                    string result = "y";
                    if (result.Length > 0 && result.StartsWith("y"))
                    {
                        send(stream, "OK " + file);
                        receiveFile(stream, file);
                        return;
                    }
                    else
                    {
                        send(stream, "ERROR " + file);
                        break;
                    }
                }
                else if (cmd.StartsWith("GET "))
                {
                    // Datei von Client zu Server
                    string file = cmd.Substring(4, cmd.Length - 4);
                    file = file.Trim(new char[] { '\r', '\n' });

                    Console.WriteLine(DateTime.Now.ToLocalTime() + " '{0}' requested. Send? [n] ", file);

                    string result = "y";
                    if (result.Length > 0 && result.StartsWith("y"))
                    {
                        send(stream, "OK " + file);
                        sendFile(stream, Path.Combine(data_dir, file));
                        return;
                    }
                    else
                    {
                        send(stream, "ERROR " + file);
                        break;
                    }
                }
                else
                {
                    send(stream, "ERROR");
                    break;
                }

            }

            stream.Close();
            Console.WriteLine(DateTime.Now.ToLocalTime() + " Connection terminated..");
        }
        
        private void receiveFile(NetworkStream stream, string filename)
        {
            using (BinaryWriter writer = new BinaryWriter(
                File.Create(Path.Combine(data_dir, filename))))
            {
                while (true)
                {
                    byte[] buffer = new byte[1024];
                    int read = stream.Read(buffer, 0, 1024);
                    writer.Write(buffer, 0, read);
                    if (read == 0)
                        break;
                }
            }

            Console.WriteLine(DateTime.Now.ToShortDateString() + 
                DateTime.Now.ToShortTimeString() + " '{0}' successfully written..", filename);
        }

        private void sendFile(NetworkStream stream, string filename)
        {
            FileStream fstream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            long s_length = fstream.Length;
            long s_read = 0;
            
            // Übertragen der Dateigröße zur Verarbeitung auf Client
            //send(stream, "LENGTH " + s_length); 

            using (BinaryReader reader = new BinaryReader(fstream))
            {
                while (s_length > s_read)
                {
                    byte[] buffer = new byte[1024];
                    int read = reader.Read(buffer, 0, 1024);
                    s_read += read;

                    sendBuffer(stream, buffer, read);

                    //int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

                    //if (pc % 5 == 0)
                    //    Percentage = pc;
                }
            }
            stream.Flush();
            Console.WriteLine(DateTime.Now.ToLocalTime()
                + " '{0}' successfully send..", filename);
        }

        private void send(NetworkStream stream, string msg)
        {
            Encoding enc = Encoding.UTF8;
            byte[] buffer = enc.GetBytes(msg + Environment.NewLine);
            stream.Write(buffer, 0, buffer.Length);
        }

        private static void sendBuffer(NetworkStream stream, byte[] buffer, int size)
        {
            stream.Write(buffer, 0, size);
        }
    }

und hier der komplette Clientcode:

Code:

public class Transfer : INotifyPropertyChanged
    {
        private int m_percentage;
        private string m_server;
        private int m_port;

        public Transfer(string server, int port)
        {
            m_server = server;
            m_port = port;
        }

        public void SendFile(string FileToSend)
        {
            TcpClient client = new TcpClient();
            client.Connect(m_server, m_port);
            NetworkStream stream = client.GetStream();

            sendMsg(stream, "SET " + Path.GetFileName(FileToSend));
            string msg = readMsg(stream);
            string accept_msg = "OK " + Path.GetFileName(FileToSend);

            System.Diagnostics.Debug.WriteLine(string.Format("GOT '{0}' - Hoping for '{1}'",
                msg, accept_msg));

            if (msg.Equals(accept_msg))
            {
                FileStream fstream = File.Open(FileToSend, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                long s_length = fstream.Length;
                long s_read = 0;

                using (BinaryReader reader = new BinaryReader(fstream))
                {
                    while (s_length > s_read)
                    {
                        byte[] buffer = new byte[1024];
                        int read = reader.Read(buffer, 0, 1024);
                        s_read += read;

                        sendBuffer(stream, buffer, read);

                        int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

                        if (pc % 5 == 0)
                            Percentage = pc;
                    }
                }
                stream.Flush();
                System.Diagnostics.Debug.WriteLine(
                    string.Format("Successfully Sent! - Exit..."));
            }
            else
                System.Diagnostics.Debug.WriteLine(
                    string.Format("File not accepted by peer..."));

            stream.Close();
            client.Close();

            System.Diagnostics.Debug.WriteLine(string.Format("Exit..."));
        }

        public void LoadFile(string path, string file)
        {
            TcpClient client = new TcpClient();
            client.Connect(m_server, m_port);
            NetworkStream stream = client.GetStream();

            sendMsg(stream, "GET " + file);
            string msg = readMsg(stream);
            string accept_msg = "OK " + file;

            System.Diagnostics.Debug.WriteLine(string.Format("Ready '{0}' - Receiving '{1}'",
                msg, accept_msg));

            // Annahme der Dateigröße zur Verarbeitung für z. B. ProgressBar
            //string length = readMsg(stream);
            //long s_length = Convert.ToInt64(length.Substring(7, length.Length - 7));
            //long s_read = 0;

            if (msg.Equals(accept_msg))
            {
                using (BinaryWriter writer = new BinaryWriter(
                    File.Create(Path.Combine(path, file))))
                {
                    while (stream.DataAvailable)
                    {
                        byte[] buffer = new byte[1024];
                        int read = stream.Read(buffer, 0, 1024);                        
                        writer.Write(buffer, 0, read);
                        if (read == 0)
                            break;

                        // Verarbeiten der Dateigröße für z. B. ProgressBar
                        //s_read += read;
                        //int pc = (int)((((double)s_read) / ((double)s_length)) * 100);

                        //if (pc % 5 == 0)
                        //    Percentage = pc;
                    }
                }

                System.Diagnostics.Debug.WriteLine(DateTime.Now.ToShortDateString() 
                    + DateTime.Now.ToShortTimeString() 
                    + string.Format(" '{0}' successfully written..", Path.Combine(path, file)));
            }
            else
                System.Diagnostics.Debug.WriteLine(
                    string.Format("File not accepted by server..."));

            stream.Close();
            client.Close();

            System.Diagnostics.Debug.WriteLine(string.Format("Exit..."));
        }

        public int Percentage
        {
            get { return m_percentage; }
            private set 
            {
                if (value != m_percentage)
                {
                    m_percentage = value;
                    NotifyPropertyChanged("Percentage");
                }
            }
        }

        private static string readMsg(NetworkStream stream)
        {
            Encoding enc = Encoding.UTF8;
            byte[] buffer = new byte[1024];
            int read = stream.Read(buffer, 0, 1024);

            string msg = enc.GetString(buffer, 0, read);
            return msg.Trim(new char[] { '\r', '\n' });
        }

        private static void sendMsg(NetworkStream stream, string msg)
        {
            Encoding enc = Encoding.UTF8;
            byte[] buffer = enc.GetBytes(msg + "\r\n");
            sendBuffer(stream, buffer, buffer.Length);
        }

        private static void sendBuffer(NetworkStream stream, byte[] buffer, int size)
        {
            stream.Write(buffer, 0, size);
        }

        #region INotifyPropertyChanged Member
        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }
        #endregion
    }

Mit dem "Do... Loop While Stream.DataAvailable" habe ich ausprobiert. Er hat den Dateidownload der Binärdaten nach 60kb abgebrochen.

brekki · 2. August 2010

Ich habe es jetzt rausgefunden.

Erst klappte es mit dem DataAvailable überhaupt nicht. Habe es asynchron versucht, fehlanzeige. Bin dann wieder zurück zum Stream.DataAvailable.

Habe jetzt das

Code:

if (read == 0)
       break;

herausgenommen und den Bereich um die Schleife für den Download von

Code:

BinaryWriter writer = new BinaryWriter(
                File.Create(Path.Combine(path, file)));

                while (true)
                {
                    byte[] buffer = new byte[1024];
                    int read = stream.Read(buffer, 0, 1024);                        
                    writer.Write(buffer, 0, read);
                    if (read == 0)
                        break;
                }

wie folgt geändert:

Code:

BinaryWriter writer = new BinaryWriter(
                    File.Create(Path.Combine(path, file)));

                int buffersize = 1024;
                byte[] buffer = new byte[buffersize];
                int read = stream.Read(buffer, 0, buffersize);
                while (stream.DataAvailable == true)
                {
                    writer.Write(buffer, 0, read);
                    read = stream.Read(buffer, 0, buffersize);
                }

Jetz läuft's. Super, Danke. Manchmal hilft nach Denkanstößen ein aufräumen

brekki · 2. August 2010

Zu früh gefreut

Es kommen nur 7kb an.
Oder sollte ich besser die Dateilänge vorab übertragen und die BufferSize auf Dateilänge setzen?

Liebe Grüße
Sebastian

brekki · 2. August 2010

Gut, vielleicht sollte ich erst rumfummeln und dann Schreiben. Ich habe es jetzt hingekriegt und der Client empfängt die ganze Datei.

Allerdings nur, wenn ich noch Thread.Sleep() mit einem Wert von mindestens 5ms in die Schleife einfüge. Das macht innerhalb eines Netzwerks für eine Datei von 5,4MB eine satte halbe bis ganze Minute für Übertragung

Herausgefunden habe ich das weil ich die Serverschleife in einen try {...} Block gesetzt habe. Mein Serverprogramm meldete mir dann eine SocketException (In den Stream kann nicht geschrieben werden, wurde von Remoteseite .... usw.).

Dann dachte ich mir: Gut, Du musst dem Client mehr Zeit geben um auf die Daten zu warten. Mit Thread.Sleep(x) klappt es jetzt und er bricht nicht mehr ab

Aber gibt es da nichts, was automatisch wartet und dann weitermacht, wenn die Daten ankommen? So anstelle einer statischen Wartezeit von 5ms?

Ich weiß nicht, ob das eventuell mit den Eigenschaften ReadTimeout und WriteTimeout des Networkstreams gehen würde. Kennt da jemand ein Beispiel oder andere Möglichkeiten?

VScan · 2. August 2010

Hi,

ich weis ja nicht wie du das ganze im Dateisystem Strukturiert hast (also die Klassen), aber ein guter Tip ist vielleicht noch, für jede Verbindung einen eigenen Thread zu starten, dann hast auch weniger Probleme denk ich ma...;

die sternchen markieren den abgeänderten Teil Deines Codes...

Code:

while (!listener.Pending())
                {
                    TcpClient client = listener.AcceptTcpClient();
                    **Thread t = new Thread(new ParameterizedThreadStart(handleClient(client));**

                }

brekki · 3. August 2010

Hi VScan,

den Server habe ich von Anfang an threaden lassen. Der Server ist Console Anwendung der die Methode Start() aufruft, die den TcpListener startet, auf Verbindungen wartet und bei Eingang einer Verbindung den Handler startet.

Code:

        public void Start()
        {
            try
            {
                listener.Start();

                // Clientverbindung akzeptieren + Clientnummer hochzählen
	TcpClient client = listener.AcceptTcpClient();
                clientNumber++;

                // Handler Objekt starten
                ClientHandler handler = new ClientHandler(client, data_dir, "Client " + clientNumber.ToString());

                // Thread für den Client erstellen
                Thread handlerThread = new Thread(new ThreadStart(handler.StartHandling));
                handlerThread.IsBackground = true;
                handlerThread.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

Das Gerüst des Client Handler sieht nach dem Laden der Klasse ClientHandler wie folgt aus:

Code:

        internal void StartHandling()
        {
            stream = client.GetStream();
            Encoding enc = Encoding.UTF8;

            while (true)
            {
                byte[] buffer = new byte[1024];
                int read = stream.Read(buffer, 0, 1024);

                if (read == 0)
                    break;

                string cmd = enc.GetString(buffer, 0, read);

                if (cmd.StartsWith("SET "))
                {
                    // Datei von Server zu Client
                    // KEINE PROBLEME, LÄUFT               
                }
                else if (cmd.StartsWith("GET "))
                {
                    // Datei von Client zu Server
                    string file = cmd.Substring(4, cmd.Length - 4);
                    file = file.Trim(new char[] { '\r', '\n' });

                    Console.WriteLine(DateTime.Now.ToLocalTime() + " '{0}' requested. Send? [n] ", file);

                    string result = "y";     // automatische Antwort, danach statt "y" --> Console.ReadLine();
                    if (result.Length > 0 && result.StartsWith("y"))
                    {
                        // Sende OK
                        send(stream, "OK " + file);
                        // Datei senden beginnt.
                        sendFile(stream, Path.Combine(data_dir, file));
                        return;
                    }
                    else
                    {
                        send(stream, "ERROR " + file);
                        break;
                    }
                }
                else
                {
                    // Fehler bei unbekannten Kommandos, läuft.
                }

            }

            stream.Close();
            Console.WriteLine(DateTime.Now.ToLocalTime() + " Connection terminated..");
        }

Es wird erst ein OK zum Client gesendet, danach wir mit der Methode sendFile() die Datei gesendet. Wenn Das abgeschlossen ist, gibt's ein return; damit der Server noch weitere Kommandos empfangen kann.

Hier nun der wichtigste Teil, die Methode sendFile():

Code:

private void sendFile(NetworkStream stream, string filename)
        {
            FileStream fstream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            long s_length = fstream.Length;
            long s_read = 0;
            
            // Übertragen der Dateigröße zur Verarbeitung auf Client
            //send(stream, "LENGTH " + s_length); 
            try
            {
                using (BinaryReader reader = new BinaryReader(fstream))
                {
                    while (s_length > s_read)
                    {
                        byte[] buffer = new byte[1024];
                        int read = reader.Read(buffer, 0, 1024);
                        s_read += read;

                        stream.Write(buffer, 0, read);
                    }
                    fstream.Close();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("FEHLER Dateiende bei " + s_read + "/" + s_length);
                Console.WriteLine(ex.ToString());
                Console.ReadLine();
            }
            
            Console.WriteLine(DateTime.Now.ToLocalTime()
                + " '{0}' successfully send..", filename);
        }

Wenn ich das Thread.Sleep(x) aus dem Client herausnehme, kommt genau in diesem Teil des Servers die Fehlermeldung:

System.IO.IOException: In die Übertragungsverbindung können keine Daten geschrieben werden: Eine vorhandene Verbindung wurde vom Remotehost geschlossen. ---> System.Net.Sockets.SocketException: Eine vorhandene Verbindung wurde vom Remotehost geschlossen

Bedeutet für mich, der Client muss irgendwie auf die Daten warten

brekki · 3. August 2010

Habe die Client-Schleife von weiter oben jetzt abgeändert.

C#:

                while (stream.DataAvailable == true)
                {
                    writer.Write(buffer, 0, read);
                    read = stream.Read(buffer, 0, buffersize);

                    if (stream.DataAvailable == false)
                        System.Threading.Thread.Sleep(10);
                }

Jetzt wartet die Schleife nicht generell, sondern nur, wenn die Daten gerade etwas länger brauchen. Sieht nicht elegant aus und ist etwas wackelig (bei 9 von 10 Versuchen klappt's)

Ich habe auch den Selbstversuch gestartet und die ReadTimeout und WriteTimeout der NetworkStream Objekte auf Server und Client eingebracht. Die TcpClient-Objekte haben auch entsprechende Eigenschaften: ReceiveTimeout und SendTimeout.

Nur eine Wirkung habe ich damit nicht erzielt. Liegt das an DataAvailable?

Dateien über TCP/IP

brekki

Steiner_B

Erfahrenes Mitglied

Steiner_B

Erfahrenes Mitglied

brekki

Grünschnabel

brekki

Grünschnabel

brekki

Grünschnabel

brekki

Grünschnabel

VScan

brekki

Grünschnabel

brekki

Grünschnabel

Neue Beiträge