C#: textBox und serialPort1

[Serge (Gast)]

Auf Form1 ist ein textBox- und ein serialPort1 Objekt.

Kommt ein Zeichen von der seriellen Schnittstelle, so soll es gleich in 
der Textbox erscheinen. Also verwende ich das dafür vorgesehene Event.

Der Witz ist nun, wenn ein Zeichen von der seriellen Schnittstelle 
kommt, dann erhalte ich eine Fehlermeldung.

Wie kann ich das Problem lösen/umgehen?

Event:

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            textBox1.AppendText(serialPort1.ReadChar().ToString());
        }

Fehlermeldung:
Ein Ausnahmefehler des Typs "System.InvalidOperationException" ist in 
System.Windows.Forms.dll aufgetreten.

Zusätzliche Informationen: Cross-thread operation not valid: Control 
'textBox1' accessed from a thread other than the thread it was created 
on.

[Felix A. (madifaxle)]

Versuche es mal wie folgt:

In deiner Empfangsroutine dieses Stück Code:

new_message = "Hallo Welt.";
this.BeginInvoke(new EventHandler(updateStatusBox));

Und dann die Routine selbst:

// Infos in die Statusbox schreiben
private void updateStatusBox(object sender, EventArgs e)
{
    Byte i;

    // Auf Anzahl Strings prüfen, wenn nicht voll dann anhängen
    if (status_text_content < 8)
    {
        status_text[status_text_content++] = new_message;
    }
}

Ich kann dir aber nicht sagen, wie man Werte direkt mit 
"this.beginInvoke" übergeben kann.

Nachtrag:
den "status_text[...]" kannst du jetzt durch deinen Textfeldzugriff 
ersetzen.

[bluppdidupp (Gast)]

Das Problem ist, das DataReceived in einem eigenen Thread läuft, und 
nicht in dem Thread aufgerufen wird, in dem die GUI-Elemente erstellt 
wurden. Auf Windows.Forms Controls (Textboxen, etc.) muss aber in der 
Regel aus dem gleichen Thread heraus zugegriffen werden, worin die 
Steuerelemente auch erstellt wurden.
Das kriegt man hin, indem man per "Invoke" den Code im Thread des 
Elements aufruft.

Eine sehr einfache Möglichkeit sieht man z.b. hier:
http://stackoverflow.com/questions/6816416/methodinvoker-vs-control-invoke
...das sähe hier dann z.B. so aus:

private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{

  string appendText=serialPort1.ReadChar().ToString();
  
  this.Invoke((MethodInvoker)delegate
  {
     // <Hier der Code der im GUI-Thread läuft>
     textBox1.AppendText(appendText);
     // </Hier der Code der im GUI-Thread läuft>
  });
}

...das "this" wäre in diesem Falle die Form. Das Invoke() ruft den Code 
dann im Thread in dem diese Form erzeugt wurde auf.

[c-hater (Gast)]

Serge schrieb:
> Auf Form1 ist ein textBox- und ein serialPort1 Objekt.

> Kommt ein Zeichen von der seriellen Schnittstelle, so soll es gleich in
> der Textbox erscheinen. Also verwende ich das dafür vorgesehene Event.
>
> Der Witz ist nun, wenn ein Zeichen von der seriellen Schnittstelle
> kommt, dann erhalte ich eine Fehlermeldung.

Das ist normal, die Events des Serialport erfolgen im Kontext 
zusätzlicher Threads, innerhalb solcher Events darf man nicht am GUI 
rumpfuschen, denn dieses ist nicht thread-sicher programmiert.

Die Lösung ist, die Events mit dem Main-Thread, der das GUI "betreibt" 
zu synchronisieren. Dafür bieten freundlicherweise fast alle 
GUI-Elemente die Methoden InvokeRequired, Invoke und BeginInvoke an.

Du brauchst also pro SerialPort-Event zwei Eventhandler, einen, der 
asynchron im Kontext des SerialPort-Threads läuft (und ggf. eine 
Vorverarbeitung der gelieferten Daten leistet) und einen zweiten, der 
synchron im Kontext des Haupthreads läuft.

>

> 
>         private void serialPort1_DataReceived(object sender, 
> System.IO.Ports.SerialDataReceivedEventArgs e)
>         {
>             textBox1.AppendText(serialPort1.ReadChar().ToString());
>         }
> 
>

Das ist sowieso ziemlicher Mist, selbst wenn die Events des SerialPort 
von Hause aus synchronisiert wären.

Das kann nur dann funktionieren, wenn nur alle Jubeljahre mal ein 
einzelnes Zeichen eintrödelt. Sobald der Sender schneller sendet, als 
der ReadTimeout bestimmt, geht das Konstrukt den Bach runter. Oder auch 
dann, wenn der ReadTimeout zwar senderseitig nicht unterschritten wird, 
aber die Verarbeitung des Zeichens länger dauert und deshalb das nächste 
Zeichen vom Sender schon da ist, bevor die Verarbeitung des aktuellen 
abgeschlossen ist.

Aber tun wir mal so, als wären diese Gegenindikationen nicht gegeben und 
die Routine würde auf Grund der Randbedingungen prinzipiell 
funktionieren  können, das einzige Problem wäre also wirklich nur die 
Thread-Synchronisation. Dann wäre die Lösung:

>

private delegate void SerialPortCharReceivedHandler(object sender, char data);

private SerialPortCharReceivedSync(object sender, char data)
{
  textBox1.AppendText(data.ToString());
}

private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
  char data=(sender as SerialPort).ReadChar();
  Invoke(new SerialPortCharReceivedHandler(SerialPortCharReceivedSync, new object[] {sender,data});
}
>

[Borislav B. (boris_b)]

Warum nicht per Lambda?

private void mySerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
   SerialPort sp = (SerialPort)sender;
   string s = sp.ReadExisting();

   this.Invoke(() => { textbox1.AppendText(s) });
}