Datenübergabe an GUI-Thread

[C# Beginner (Gast)]

Hallo,
ich habe einen Thread, der Daten von der seriellen Schnittstelle 
einliest.
Diese sollen auf der Console ausgegeben werden.
Die Ausgabe soll im eigenen Thread stattfinden, um den Einlsese-Thread 
nicht zu blockieren.
Dieser Ansatz funktioniert nicht ganz so toll:

    while (_continue)
    {
      try
      {
        if (_serialPort.BytesToRead > 0) {
          var ret = _serialPort.Read(arr,0,_serialPort.BytesToRead);
          if (ret > 0) {
            this.BeginInvoke((MethodInvoker) delegate {
              for (int i=0;i<ret;i++) {
                Console.WriteLine("{0,5}:{1,2:X}",cnt,arr[i]);
                cnt++;
              }
            });
          }
        }
      }
      catch (TimeoutException) { }
    }

Das Problem ist, wenn die Ausgabe-Routine verzögert ist, dann gibt der 
WriteLine nicht die Werte (arr[]) aus, mit der das delegate aufgerufen 
wurde, sondern die bereits aktualisierten.
D.h. werden die Werte 1,2,3,4,5 empfangen, so gibt er z.B. 1,2,4,4,5 
aus.
Ich hatte schon arr[] zwischengespeichert, damit die ursprünglichen 
Werte für das delegate erhalten blieben, aber das funktioniert auch 
nicht.
Was tun?

[Manfred M. (bittbeisser)]

Mit C# kenne ich mich nicht aus. Aber sobald du mit mehreren Threads 
arbeitest, musst du dich auch mit IPC (inter process communication) und 
Mutexe befassen.

Was du da vor hast ist eigentlich ein typischer Anwendungsfall für einen 
Ringpuffer oder ein FIFO, auf den immer nur ein Thread zur Zeit 
zugreifen darf.

Trivial ist des jedenfalls nicht.

[nicht"Gast" (Gast)]

Moin,

tja, das Leid mit den Threads^^

Der Weg, den du gehst ist übrigens ungewöhnlich. Die Klasse SerialPort 
kann bereits asyncron lesen. Da brauchst du keinen eigenen Thread für 
aufmachen.

SerialPort myPort;

void init()
{
    myPort = new SerialPort("com1");
    myPort.DataReceived += dataReveived;
    myPort.Open()

}


StringBuilder dataStorage = new StringBuilder();
Object lockObject = new Object();
void dataRecevied(Object sender, SerialDataReceivedEventArgs e)
{
    // wird aufgerufen, wenn Daten am Port eintrudeln.
    
    lock(lockObject)
    {
        var readData = myPort.ReadExisting();
        dataStorage.Append(readData);
        printNewData(readData);    
    }
}

Ich hab das ganze natürlich vereinfacht dargestellt.

Das hat für dich vor allem den Vorteil, dass beim Eintrudeln von Daten 
ein neuer Aufruf der Methode erfolgt. Will sagen, die lokalen Variablen 
werden nicht Überschrieben. Egal, ob die ausgegeben werden oder nicht.

Ich weiß grad gar nicht, was ich noch schreiben soll. Na ja, wenn du 
Fragen hast, dann raus damit :)