TcpListener - große Datenpakete empfangen

Moin !

Ich bräuchte mal einen Tip von euch zum Thema TcpListener und große Datenpakete.

Im Moment versuche ich eine CommandLine Log Console für SmartInspect zu schreiben. Als Grundlage nutze ich diesen threaded TCP Server:
Simple Threaded TCP Server

Ich kann auch schon mit der SmartInspect Lib "reden". Hier ist beschrieben wie das geht:
SmartInspect Log Formats and Protocols

Das ganze funktioniert schon ganz gut wenn es kleine TCP Pakete sind die komplett übertragen werden. Also wenn man z.B. einen String oder einen Wert loggt.
Wenn ich aber größere Datenmengen übertrage (z.B. eine Objektbeschreibung, XML Struktur, ...) dann klappt das nicht mehr problemlos.

Wenn ich das richtig sehe, dann liest diese Zeile hier:

bytesRead = clientStream.Read(message, 0, 4096);

max. 4096 Bytes vom Netzwerkstream, oder?
So steht es jedenfalls in der Hilfe:

The Read operation reads as much data as is available, up to the number of bytes specified by the size parameter

Nun frage ich mich aber was die beste Herangehensweise wäre. *Den Size Wert von 4096 rauf setzen auf z.B. 2000000. Ich denke größere Pakete werde ich nicht bekommen. *Die Größe des Datenpakets aus den ersten 4096 Byte auslesen und einen Buffer in der Größe einrichten. Dann alle neuen Pakete so lange anhängen bis der Buffer entsprechend gefüllt ist? Diese Variante erscheint mir recht kompliziert. *Generell aneres Vorgehen?! Evtl. über ClientStream.DataAvailable?

**Nachtrag ... **

Den Size Wert von 4096 rauf setzen auf z.B. 2000000.

Das klappt schon mal nicht 😃

Die Größe des Datenpakets (...) auslesen (...). Dann (...) Pakete so lange anhängen bis (...) Buffer (...) gefüllt ist oder Verbindung verloren geht.

Eine wirklich bessere/andere Vorgehensweise wüsste ich jetzt auch nicht.
Modifikation: Daten in einem Buffer schreiben, bis es nichts mehr zu lesen gibt.
Danach erst Buffer auswerten.

Also bei mir ließt er auch mehr als 4096 Bytes.
Standartmäßig arbeite ich immer so, dass ich am Anfang die Länge der zu sendenden Daten send, und dann die länge der Daten. Mein Buffer wird dann mit den Daten gefüllt, er hat die entsprechende Größe.

Moin !

Also bei mir ließt er auch mehr als 4096 Bytes.

Klar. Ich habe eben bei Read mal 2000000 angegeben. Dann liest er bei mir zwischen 20000-30000 Byte große Stücke vom Paket.

Standartmäßig arbeite ich immer so, dass ich am Anfang die Länge der zu sendenden Daten send, und dann die länge der Daten. Mein Buffer wird dann mit den Daten gefüllt, er hat die entsprechende Größe.

Hättest du davon evtl. den Code?

Client:

//lese länge aus daten
            byte[] lengthArr = new byte[4];
            int offset = 0;
            int i = 0;
            while (offset < lengthArr.Length)
            {
                offset += ns.Read(lengthArr, offset, lengthArr.Length - offset);                
            }
            //länge convertieren aus byteArray
            int length = BitConverter.ToInt32(lengthArr, 0);

            //Buffer der entsprechenden Größe
            byte[] buffer = new byte[length];
            offset = 0;

            //empfange buffer
            while (offset < length)
            {
                offset += ns.Read(buffer, offset, length - offset);
            }

Danke 👍

Werde ich gleich mal testen.

Hier noch der Sender

//buffer mit Daten zum Senden gefüllt
byte[] buffer = null;

byte[] lengthArr = BitConverter.GetBytes(buffer.Length);

ns.Write(lengthArr, 0, 4);
ns.Write(buffer, 0, buffer.Length);

Moin !

@PPK:
Das funktioniert sehr gut 👍

Vielen Dank für den Codeschnibbl 8)