Label refreshen und Invoke

Hallo liebe Community,

ich bin neu zu C# und dem Forum hier.

Ich habe ein GUI erstellt womit ich "checke" ob ein Process existiert oder nicht. Doch ich habe Probleme beim updaten der Label.

Wenn ich den Target-Process öffne, dann mein Tool, dann steht da "Process Found!"
Edit Abt: Externes Bild entfernt.

Doch wenn ich den Target-Process schließe, bleibt mein Label bei "Process Found!"

Und bei "Process Not Found!" ist es genau andersrum.
Edit Abt: Externes Bild entfernt.

Mein Code:

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            int pID = m.GetProcIdFromName("AoEDE_s");

            while (true)
            {
                if (pID > 0) //Falls der Process existiert
                {
                    openProc = m.OpenProcess(pID);
                    processLabel.Invoke(new MethodInvoker(delegate () { processLabel.Text = "Process Found!"; }));
                    processLabel.ForeColor = Color.Green;
                    processLabel.Invoke(new MethodInvoker(delegate () { processLabel.Update(); }));
                    processLabel.Invoke(new MethodInvoker(delegate () { processLabel.Refresh(); }));
                }
                else if (pID == 0) //Falls der Process nicht existiert
                {
                    processLabel.Invoke(new MethodInvoker(delegate () { processLabel.Text = "Process not Found!"; }));
                    processLabel.ForeColor = Color.Red;
                    processLabel.Invoke(new MethodInvoker(delegate () { processLabel.Update(); }));
                    processLabel.Invoke(new MethodInvoker(delegate () { processLabel.Refresh(); }));
                }
                Thread.Sleep(500);
            }
        }

Ich muss noch sagen, dass processLabel.Text = "Process Found!" so nicht geklappt hat. Es gab immer ein Error dann habe ich hier im Forum das mit dem Invoke gefunden.
Bin mir auch nicht sicher ob ich das richtig benutze, aber so bekomme ich kein Error.

Ich bedanke mich für jegliche Hilfe und Antwort

MfG,
helios300

Damit sich in deiner Schleife etwas ändert, mußt du die ProcessID jedesmal abfragen, also an den Anfang des Schleifenblocks verschieben.
Dann solltest du aber zusätzlich nur auf Änderung dessen die Ausgaben durchführen (dir also die aktuelle ProcessID merken und auf Ungleichheit abfragen).

Außerdem kannst du auch mehrere Anweisungen innerhalb des Invoke ausführen (außerdem mit einem Lambda-Ausdruck auch eleganter):

processLabel.Invoke(() => {
    processLabel.Text = "Process Found!";
    processLabel.Refresh(); // ein zusätzliches Update ist hier überflüssig
});

Eleganter geht es jedoch direkt mit dem Ereignis ProgressChanged, da dieser automatisch im UI-Thread ausgeführt wird (also kein Invoke mehr nötig ist).

s.a. [FAQ] Controls von Thread aktualisieren lassen (Control.Invoke/Dispatcher.Invoke)

Desweiteren ist der BackgroundWorker etwas veraltet, stattdessen nutzt man (seit .NET 4) asynchrone Programmierung (mittels async/await) dafür - bedeutet aber für einen Anfänger etwas Zeit zum Einarbeiten.

Die Verwendung von Threads und dem Backgroundworker sind seit vielen vielen Jahren nicht mehr notwendig.
Mittlerweile gibts dafür Tasks und die asynchrone Programmierung.

Beachtest Du [Artikel] Drei-Schichten-Architektur dann würdest Du diese Logik auslagern und nicht in der UI rennen lassen (macht man nicht).
Dort hättest Du zum Beispiel eine Methode StartProcessSearchAsync, die einen Task zurück liefert.
Innerhalb des ausgelagerten Tasks kannst Du dann - ohne dass die UI blockiert - Dein Prozess suchen.

Die Prozesse kannst Du dann als Methoden-Rückgabe oder über Events bekannt geben.

PS: bitte keine Bilder einbetten, siehe [Hinweis] Wie poste ich richtig?
Ich hab die Bilder aus Deinem Beitrag entfernt.

Ok das werde ich ausprobieren, danke!
Komisch das Backgroundworker so veraltet ist. Auf youtube nutzen das noch sehr viele die "c# tutorials" aufnehmen.

Danke für die Antwort!
Ok keine Bilder. Ich lese mir die Woche die Regeln durch =)

Auf youtube nutzen das noch sehr viele die "c# tutorials" aufnehmen.

Dann sind die Tutorials entweder sehr sehr alt oder deutlich verbesserungswürdig.
Oder die Tutorials wollen bewusst auf Tasks verzichten, um die Lernhürde zu async/await zu umgehen; kann ich nicht abschätzen.

Ok sorry! 😁