Come faccio a far funzionare un eventhandler in modo asincrono?

Question

Sto scrivendo un programma Visual C# che esegue un ciclo continuo di operazioni su un thread secondario. Occasionalmente quando quel thread termina un'attività, voglio che attivi un eventhandler. Il mio programma lo fa, ma quando viene attivato il gestore eventi, il thread secondario attende fino al termine del gestore eventi prima di continuare il thread. Come posso farlo continuare? Ecco il modo in cui attualmente lo ho strutturato ...

class TestClass 
{ 
    private Thread SecondaryThread; 
    public event EventHandler OperationFinished; 

    public void StartMethod() 
    { 
    ... 
    SecondaryThread.Start();  //start the secondary thread 
    } 

    private void SecondaryThreadMethod() 
    { 
    ... 
    OperationFinished(null, new EventArgs()); 
    ... //This is where the program waits for whatever operations take 
     //place when OperationFinished is triggered. 
    } 

} 

Questo codice fa parte di un'API per uno dei miei dispositivi. Quando viene attivato l'evento OperationFinished, voglio che l'applicazione client sia in grado di fare tutto ciò che è necessario (cioè aggiornare la GUI di conseguenza) senza interferire con l'operazione API.

Inoltre, se non si desidera passare alcun parametro al gestore eventi, la mia sintassi è corretta utilizzando OperationFinished(null, new EventArgs())?

Answer 1

Quindi vuoi sollevare l'evento in modo da impedire agli ascoltatori di bloccare il thread in background? Dammi un paio di minuti per fare un esempio; è piuttosto semplice :-)

Eccoci: prima una nota importante! Ogni volta che si chiama BeginInvoke è necessario chiamare il corrispondente EndInvoke, altrimenti se il metodo richiamato ha generato un'eccezione o restituito un valore, il thread ThreadPool non verrà mai rilasciato nuovamente nel pool, causando una perdita di thread!

class TestHarness 
{ 

    static void Main(string[] args) 
    { 
     var raiser = new SomeClass(); 

     // Emulate some event listeners 
     raiser.SomeEvent += (sender, e) => { Console.WriteLine(" Received event"); }; 
     raiser.SomeEvent += (sender, e) => 
     { 
      // Bad listener! 
      Console.WriteLine(" Blocking event"); 
      System.Threading.Thread.Sleep(5000); 
      Console.WriteLine(" Finished blocking event"); 
     }; 

     // Listener who throws an exception 
     raiser.SomeEvent += (sender, e) => 
     { 
      Console.WriteLine(" Received event, time to die!"); 
      throw new Exception(); 
     }; 

     // Raise the event, see the effects 
     raiser.DoSomething(); 

     Console.ReadLine(); 
    } 
} 

class SomeClass 
{ 
    public event EventHandler SomeEvent; 

    public void DoSomething() 
    { 
     OnSomeEvent(); 
    } 

    private void OnSomeEvent() 
    { 
     if (SomeEvent != null) 
     { 
      var eventListeners = SomeEvent.GetInvocationList(); 

      Console.WriteLine("Raising Event"); 
      for (int index = 0; index < eventListeners.Count(); index++) 
      { 
       var methodToInvoke = (EventHandler)eventListeners[index]; 
       methodToInvoke.BeginInvoke(this, EventArgs.Empty, EndAsyncEvent, null); 
      } 
      Console.WriteLine("Done Raising Event"); 
     } 
    } 

    private void EndAsyncEvent(IAsyncResult iar) 
    { 
     var ar = (System.Runtime.Remoting.Messaging.AsyncResult)iar; 
     var invokedMethod = (EventHandler)ar.AsyncDelegate; 

     try 
     { 
      invokedMethod.EndInvoke(iar); 
     } 
     catch 
     { 
      // Handle any exceptions that were thrown by the invoked method 
      Console.WriteLine("An event listener went kaboom!"); 
     } 
    } 
} 

Answer 2

Guarda la classe BackgroundWorker. Penso che faccia esattamente quello che stai chiedendo.

MODIFICA: Quello che penso si stia chiedendo è come attivare un evento quando è completata solo una piccola parte dell'attività complessiva in background. BackgroundWorker fornisce un evento chiamato "ProgressChanged" che consente di riportare al thread principale che una parte del processo generale è completa. Quindi, quando tutto il lavoro asincrono è completo, solleva l'evento "RunWorkerCompleted".

Answer 3

Inoltre, se non si desidera passare alcun parametro al gestore eventi, la mia sintassi è corretta utilizzando OperationFinished (null, new EventArgs())?

No. In genere, si sarebbe chiamata come:

OperationFinished(this, EventArgs.Empty); 

Si dovrebbe sempre passare un oggetto come mittente - ci si aspetta nel modello (anche se in genere ignorato). EventArgs.Empty è anche meglio del nuovo EventArgs().

Al fine di sparare questa in un thread separato, l'opzione più semplice è probabilmente quella di utilizzare solo il pool di thread:

private void RaiseOperationFinished() 
{ 
     ThreadPool.QueueUserWorkItem(new WaitCallback((s) => 
      { 
       if (this.OperationFinished != null) 
        this.OperationFinished(this, EventArgs.Empty); 
      })); 
} 

Detto questo, sollevando un evento su un thread separato è qualcosa che dovrebbe essere accuratamente documentato, in quanto potrebbe causare comportamenti imprevisti.

Answer 4

Provare i metodi BeginInvoke e EndInvoke sul delegato dell'evento, che vengono restituiti immediatamente e consentono di utilizzare il polling, un handle di attesa o una funzione di callback per notificare quando il metodo è stato completato. Vedi here per una panoramica; nel tuo esempio, l'evento è il delegato che utilizzerai

Answer 5

Preferisco definire un metodo che si passa al thread figlio come delegato che aggiorna l'interfaccia utente. Prima di definire un delegato:

public delegate void ChildCallBackDelegate(); 

Nel thread figlio definire un membro delegato:

public ChildCallbackDelegate ChildCallback {get; set;} 

Nella classe chiamata definire il metodo che aggiorna l'interfaccia utente. Avrai bisogno di avvolgerlo nel dispatcher del controllo target dal momento che viene chiamato da un thread separato. Nota il BeginInvoke. In questo contesto EndInvoke non è richiesto:

private void ChildThreadUpdater() 
{ 
    yourControl.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background 
    , new System.Threading.ThreadStart(delegate 
     { 
     // update your control here 
     } 
    )); 
} 

Prima di lanciare il tuo thread figlio, impostare la proprietà ChildCallBack:

theChild.ChildCallBack = new ChildCallbackDelegate(ChildThreadUpdater); 

Poi, quando il filo bambino vuole aggiornare il genitore:

ChildCallBack(); 

Answer 6

Con il Task Parallel Library è ora possibile effettuare le seguenti operazioni:

Task.Factory.FromAsync((asyncCallback, @object) => this.OperationFinished.BeginInvoke(this, EventArgs.Empty, asyncCallback, @object), this.OperationFinished.EndInvoke, null); 

Answer 7

Forse Method2 o method3 di seguito possono aiutare :)

public partial class Form1 : Form 
{ 
    private Thread SecondaryThread; 

    public Form1() 
    { 
     InitializeComponent(); 

     OperationFinished += callback1; 
     OperationFinished += callback2; 
     OperationFinished += callback3; 
    } 

    private void Form1_Load(object sender, EventArgs e) 
    { 
     SecondaryThread = new Thread(new ThreadStart(SecondaryThreadMethod)); 
     SecondaryThread.Start(); 
    } 

    private void SecondaryThreadMethod() 
    { 
     Stopwatch sw = new Stopwatch(); 
     sw.Restart(); 

     OnOperationFinished(new MessageEventArg("test1")); 
     OnOperationFinished(new MessageEventArg("test2")); 
     OnOperationFinished(new MessageEventArg("test3")); 
     //This is where the program waits for whatever operations take 
      //place when OperationFinished is triggered. 

     sw.Stop(); 

     Invoke((MethodInvoker)delegate 
     { 
      richTextBox1.Text += "Time taken (ms): " + sw.ElapsedMilliseconds + "\n"; 
     }); 
    } 

    void callback1(object sender, MessageEventArg e) 
    { 
     Thread.Sleep(2000); 
     Invoke((MethodInvoker)delegate 
     { 
      richTextBox1.Text += e.Message + "\n"; 
     }); 
    } 
    void callback2(object sender, MessageEventArg e) 
    { 
     Thread.Sleep(2000); 
     Invoke((MethodInvoker)delegate 
     { 
      richTextBox1.Text += e.Message + "\n"; 
     }); 
    } 

    void callback3(object sender, MessageEventArg e) 
    { 
     Thread.Sleep(2000); 
     Invoke((MethodInvoker)delegate 
     { 
      richTextBox1.Text += e.Message + "\n"; 
     }); 
    } 

    public event EventHandler<MessageEventArg> OperationFinished; 

    protected void OnOperationFinished(MessageEventArg e) 
    { 
     //##### Method1 - Event raised on the same thread ##### 
     //EventHandler<MessageEventArg> handler = OperationFinished; 

     //if (handler != null) 
     //{ 
     // handler(this, e); 
     //} 

     //##### Method2 - Event raised on (the same) separate thread for all listener ##### 
     //EventHandler<MessageEventArg> handler = OperationFinished; 

     //if (handler != null) 
     //{ 
     // Task.Factory.StartNew(() => handler(this, e)); 
     //} 

     //##### Method3 - Event raised on different threads for each listener ##### 
     if (OperationFinished != null) 
     { 
      foreach (EventHandler<MessageEventArg> handler in OperationFinished.GetInvocationList()) 
      { 
       Task.Factory.FromAsync((asyncCallback, @object) => handler.BeginInvoke(this, e, asyncCallback, @object), handler.EndInvoke, null); 
      } 
     } 
    } 
} 

public class MessageEventArg : EventArgs 
{ 
    public string Message { get; set; } 

    public MessageEventArg(string message) 
    { 
     this.Message = message; 
    } 
} 

}