Daten in eine Datei speichern welche von einen TCP/IP Server gelesen werden

Ich muss mir eine Statistik von eine TPC/IP Server einlesen.
Dazu muss man zuerst eine XML-Datei an den Server sendet.
Der Server antwortet, indem es UTF-8-codierte Daten in einem durch Tabulatoren getrennten Format zurücksendet.

Es funktioniert alles bis auf die Darstellung der Umlaute. Diese werden leider nicht richtig dargestellt.

Im Anhang ist noch das Kommunikationsprotokoll für den Server

Anbei bei Code

static void read()
        {
            string server = "10.0.15.248";
            string message = "";
            string STX = "\x02";
            string ProtocolType = "\x79";
            string ETX = "\x03";
            string NAK = "\x15";

            try
            {
                // Create a TcpClient.
                // Note, for this client to work you need to have a TcpServer 
                // connected to the same address as specified by the server, port
                // combination.
                Int32 port = 1616;
                TcpClient client = new TcpClient(server, port);

                // Translate the passed message into ASCII and store it as a Byte array.
                Byte[] data = System.Text.Encoding.ASCII.GetBytes(STX);

                // Get a client stream for reading and writing.
                //  Stream stream = client.GetStream();

                NetworkStream stream = client.GetStream();

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

                Console.WriteLine("Sent: {0}", message);

                // Receive the TcpServer.response.

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

                // String to store the response ASCII representation.
                String responseData = String.Empty;

                // Read the first batch of the TcpServer response bytes.
                Int32 bytes = stream.Read(data, 0, data.Length);
                responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
                //Console.WriteLine("Received: {0}", responseData);

                //Nun mein Teil

                if (responseData == STX)
                {
                    string towrite = "";
                    string last;
                    
                    data = System.Text.Encoding.ASCII.GetBytes(ProtocolType);
                    stream.Write(data, 0, data.Length);

                    var sendxml = File.ReadAllBytes("C:\\dummy\\XXX-IV\\Test\\statisticsExport.xml");
                    stream.Write(sendxml, 0, sendxml.Length);

                    //Send ETX so XXX now we are done
                    data = System.Text.Encoding.ASCII.GetBytes(ETX);
                    stream.Write(data, 0, data.Length);

                    StreamReader streamReader = new StreamReader(stream);
                    StringBuilder stringBuilder = new StringBuilder();                   

                    if (stream.CanRead)
                    {      
                        byte[] myReadBuffer = new byte[1];                       
               
                        int numberOfBytesRead = 0;
                                                    
                        do
                        {                            
                            numberOfBytesRead = stream.Read(myReadBuffer, 0, myReadBuffer.Length);                         
                           
                            last = Encoding.UTF8.GetString(myReadBuffer, 0, 1);                          

                            if (last != ETX && last != NAK)
                            {                                
                                if (last != ETX)
                                {
                                    towrite = towrite + Encoding.UTF8.GetString(myReadBuffer, 0, numberOfBytesRead);                                    
                                }                                                               
                            }
                            else
                            {
                                Console.WriteLine("Letztes");
                               
                            }
                            
                        }
                        while (stream.DataAvailable);
                      
                        towrite = towrite.Trim('\0'); //Damit werden die Null Werte gelöscht
                       
                        using (var DateiOut = new StreamWriter("C:\\dummy\\ausgabe.txt",false,Encoding.UTF8))
                            {                                
                                DateiOut.WriteLine(towrite);
                            }

                        if (last.ToString() == ETX)
                        {
                            Console.WriteLine("Hallo richtig Read fertig");                          
                        }
                        //Send ETX so Woodeye now we are done
                        data = System.Text.Encoding.ASCII.GetBytes(ETX);
                        stream.Write(data, 0, data.Length);
                      
                    }
                    else
                    {
                        Console.WriteLine("Sorry.  You cannot read from this NetworkStream.");
                    }

                }
                else
                {
                    Console.WriteLine("nicht gefunden");
                }

                //End von meinen Teil

                // Close everything.
                stream.Close();
                client.Close();
            }
            catch (ArgumentNullException e)
            {
                Console.WriteLine("ArgumentNullException: {0}", e);
            }
            catch (SocketException e)
            {
                Console.WriteLine("SocketException: {0}", e);
            }

            Console.WriteLine("\n Press Enter to continue...");
            Console.Read();
        }
 

Wenn ich diese Zeile byte[] myReadBuffer = new byte[1];
auf byte[] myReadBuffer = new byte[16]; ändere dann funktionieren die Umlaute.
Aber ich habe dann das Problem, dass ich nicht das Ende der Übertragung finde. Der Server
sendet nämlich ETX am Ende der Übertragung und dies muss ich erkennen, da ich dann auch
ein ETX an den Server senden muss.

Wie könnte ich das lösen?
Besten Dank
stony

Hi,

naja - warum das so ist erklärt sich mit Hilfe von UT8 sehr einfach. Nicht jedes Zeichen braucht nur ein Byte bei UTF8 - manche (inbesondere Umlaute) eben mehr - dass das schief läuft ist ja dann kein Wunder.

Auf der anderen Seite: Wer hindert dich daran je ein Byte zu lesen - und dann simpel zu schauen:
Ist es ein "ETX" mit ASCII?
Nein: Byte an's Ende einer Liste von Bytes hängen (die später als UTF-8 kodierter String als gesamtes gelesen werden)
Ja: Byte-Liste als UTF8 lesen und das ETX senden

LG