C# - Aus Thread eine Funktion ausrufen

[Draco (Gast)]

Ich habe ein Programm, welches mir in einem Thread einen UDP String 
ausließt. Nun würde ich gerne durch diesen Thread eine externe Funktion 
starten, welche nicht in diesem Thread läuft.

Wie stelle ich das am dümmsten an.

Einen Wert kann ich ja mit invoke bzw. invokeRequired übergeben. Ich 
möchte halt aber einfach nur eine Funktion "anstoßen".

[Peter II (Gast)]

Draco schrieb:
> Nun würde ich gerne durch diesen Thread eine externe Funktion
> starten, welche nicht in diesem Thread läuft.

was soll das heißen "welche nicht in diesem Thread läuft"?

eine Funktion läuft in dem Thread wo sie gestartet wird. Was hindert 
dich daran also die Funktion einfach zu starten?

[Frank L. (frank_l)]

Hallo,

da gibt es zwei Möglickeiten:

1. permanent laufender Thread
eine Callback Funktion kann Dir jedesmal den String an eine andere 
Stelle in Deinem Programm übergeben.

2. Abgeleitete Thread-Klasse und nur einmal laufend
Property declarieren und im OnComplete des Thread setzen. Anschließend 
im Programm abfragen.

Gruß
Frank

[Fuzzi59 (Gast)]

Das hört sich so an, als wölltest du eine Methode asynchron aufrufen. 
Dafür solltest du dir mal folgende Seite ansehen: 
http://openbook.rheinwerk-verlag.de/visual_csharp_2012/1997_15_002.html#dodtp6cd94ef0-9aae-45b1-9de3-f66b3125d6e4

[Pedram G. (ganjeh_hadidi)]

Könnten Sie bitte etwas Code mitposten/uploaden? Sie müssen nicht Alles 
posten. Es reicht nur den Funktionskopf + "..." + den Return-Anweisung + 
etwas genauere Beschreibung zu Posten, was (nochmal Funktoinskopf +/- 
Klassen-Schnittstellen) Ihre UDP-Lese-Thread starten möchte.

Soweit ich Sie verstanden habe...

Sie haben ein Program "P", welches einen Thread "T" startet.
"T" liest ein UDP Packet aus und erzeugt ein Objekt (von bel. Typ), 
welches die Daten des UDP-Packets in sich trägt.
Und nun möchten Sie, dass dieses Objekt von "T" an "P" zurückgegeben 
wird? Stimmt das so?

Falls ich Sie richtig verstanden habe, dann können Sie z.B. so diesen 
Wert (für alle Interessenten) aktualisieren:

public class XYZ
{
/*
   Deklariert den Signatur von Methoden die sich bei Event (unten),
   zwecks Benachrichtigung, registrieren können.
*/
public delegate UdpChangedEvent(MyUdp pMyUdp);

/*
  Wird aufgerufen/angestoßen, wenn sich der Eigenschaft-Wert "UDP" (weiter unten) ändert.
*/
public event UdpChangedEvent UdpChanged;

private void NotifyUdpChanged(MyUdp pMyUdp)
{
   if(UdpChanged != null)
      UdpChanged(pMyUdp);
}

private MyUDP udp = null;

/*
   Eigenschaft.
*/
public MyUDP UDP
{
   get { return udp; }
   set
   {
      if(udp == value)
         return;

      udp = value;
      NotifyUdpChanged(udp);
   }
}


/* Und so kann/können der/die Interessent(en) sich registrieren, um von Änderung des UDP-Wertes automatisch benachichtigt zu werden... */

var xyz = new XYZ();
xyz.UdpChanged += Die_Handler_Methode;

/* Und "Die_Handler_Methode" ist nun überall dort wo man benachrichtigt und dann etwas machen möchte */
private void Die_Handler_Methode(MyUDP myUdp)
{
   Console.WriteLine(myUdp);
   // udg. usw. usf.
}

[Dennis H. (c-logic)]

Hab ein ähnliches Problem gehabt mit unterschiedlichen Threads zwar im 
selben Programm, aber die Delegaten (direkt aufgerufen) haben mich 
allein gelassen.

Ich habs mit Action gelöst aus dem einen Workerthread ins Formular dann 
aufgerufen.

Die Empfangsfunktion existiert im Formular:
public void Method1(int x) ...

Im Workerthread:
Action<int> action = new Action<int>(Method1,5);
Formular.Invoke(action);

[Dennis H. (c-logic)]

Mal ein Funktionelles Beispiel

Die Empfangsfunktion existiert im Formular:
public partial class MainForm : Form
{
 private Class1 cl1=new Class1();
 public MainForm() {
  InitializeComponent();
  this.backgroundWorker1.DoWork += new DoWorkEventHandler(cl1.DoWork);
 }
 public void CallBack(int i) {
  button1.BackColor=Color.Yellow;
 }
 void Button1Click(object sender, EventArgs e) {
  if(!backgroundWorker1.IsBusy) {
   button1.BackColor=Color.Green;
   backgroundWorker1.RunWorkerAsync(this);
  }
 }
 public class MyDoWorkEventArgs {
  public MainForm mf;
  public MyDoWorkEventArgs(MainForm mf) {
   this.mf=mf;
  }
 }
}

Dem Workerthread muß man allerdings als Argument auch das 
Formular-Object übergeben.
Im Workerthread/Class1:
public class Class1
{
  public void DoWork(object sender, DoWorkEventArgs e) {
    Thread.Sleep(1000);
    MainForm mf=e.Argument as MainForm;
    mf.Invoke(new Action<int>(mf.CallBack),5);
  }
}

[Frank L. (frank_l)]

Leute Leute,

wenn Ihr schon Vorschläge bringt, dann macht es direkt richtig.

Einen Callback in den Formularthread kann man ganz gemütlich mit ein 
paar Zeilen Code abfrühstücken.

//  muss der Eventnotation entsprechen
private delegate void EventCallbackDelegate(string value)
private void EventCallbackExecute(string value)
{
// hier das eigentliche Doing
}

private void EventCallback(string value)
{
  if (InvokeRequired)
  {
    Invoke(new EventCallbackDelegate(EventCallbackExecute), value);
    return;
  }
  EventCallbackExecute(value)
}

Registriert wird die Funktion EventCallback in der Klasse, wo sie 
aufgerufen werden soll. Hier z.B. im Thread und oder in anderen Klassen.

Auf diese Weise kann der Callback ohne Probleme in Task oder Thread oder 
Backgroundworker verwendet werden.

Ganz elegant funktioniert das ganze dann mit Task, await und async.

Gruß
Frank

[Dennis H. (c-logic)]

@Frank L:

Hab gerade mal ausprobiert.
Die Variante funktioniert auch.

Problem bei mir war, daß der BackgroundWorker in einer anderen Klasse.

Variante 1:
mf.Invoke(new Action<int>(mf.CallBack),5);

macht automatisch ein delegate draus.

Variante 2: (Frank)
mf.Invoke(new MainForm.EventCallbackDelegate(mf.CallBack),5);

Machen beide das gleiche.

[Draco (Gast)]

Danke Leute, das was Frank gepostet hat, war das was ich gesucht habe. 
Aber es ist schön zu sehen das es ja doch mehrere Möglichkeiten gibt 
solch ein Problem anzugehen.

Das Problem war jenes, das ich in dem eigentlich Thread zu auslesen, 
nicht die Berechnung durchführen lassen wollte. Die Übergabe an 
Formularinhalte aber enorme Invoke Ausmaße angenommen hatte.

Ich hatte mir dann als "Zwischenbehelf" ein TimerObject angelegt welches 
regelmäßig prüft ob denn ein neues Paket empfangen wurde und dies dann 
abarbeitete. Das ist natürlich aus Sicht der Performance, den 
Möglichkeiten und des Code-Designs absoluter Dünschiss, aber es hatte 
funktioniert :D So in etwa:

//....
volatail bool isSet = false;
//....
Listener = new Thread(UDP_Listener);
Listener.start();
//....

public void UDP_Listener()
{
   //....
   bool done = false;
   while (!done)
   {
     //...
     isSet = true;
   }
}



private void tim_UDP_Tick(object sender, EventArgs e)
{
   if(isSet)
   {
      //Hier die Berechnung und die Ausgabe ausführen
   }      
}

//....

Den Timer habe ich alle 10ms aufrufen lassen, egal ob ich Daten bekommen 
hatte oder nicht.

Keine Angst, hab ich nun natürlich ersetzt. :)

[Peter II (Gast)]

Draco schrieb:
> Das Problem war jenes, das ich in dem eigentlich Thread zu auslesen,
> nicht die Berechnung durchführen lassen wollte.

hättest du das nicht gleich schreiben können?

Ich würde für die Berechnung einen eigenen Threads schreiben. Die 
UDP-Daten werden in ein Liste (Queue) gesteckt und der Thread mit einen 
Event geweckt.

Der Thread prüft in eine Endlosschleife ob Daten in der Queue vorhanden 
sind, wenn nein wartet er auf das Event.

Das muss braucht man nur eine ein Lock auf die Liste und ein Event 
objekt. Das ganze invoke braucht man dann nicht.

[Horst (Gast)]

Falls du einen Ansatz zum Suchen brauchst: Producer Consumer Queue.