最乾淨的方式來調用跨線程事件

Question

我發現.NET事件模型是這樣的，我經常會在一個線程上引發事件並在另一個線程上偵聽它。我想知道從後臺線程將事件編組到我的UI線程的最乾淨的方式是什麼。

基於社區的建議，我用這個：

// earlier in the code 
mCoolObject.CoolEvent+= 
      new CoolObjectEventHandler(mCoolObject_CoolEvent); 
// then 
private void mCoolObject_CoolEvent(object sender, CoolObjectEventArgs args) 
{ 
    if (InvokeRequired) 
    { 
     CoolObjectEventHandler cb = 
      new CoolObjectEventHandler(
       mCoolObject_CoolEvent); 
     Invoke(cb, new object[] { sender, args }); 
     return; 
    } 
    // do the dirty work of my method here 
} 

Answer 1

一對夫婦的意見：

• 不要創建簡單的代表明確這樣的代碼，除非你是2.0以上，所以你可以使用：

BeginInvoke(new EventHandler<CoolObjectEventArgs>(mCoolObject_CoolEvent), 
       sender, 
       args); 

• 此外，您不需要創建和填充對象數組，因爲args參數是「params」類型，因此您只需傳入列表即可。

• 我可能會傾向於Invoke超過BeginInvoke因爲後者會導致代碼被異步調用這可能是也可能不是你追求的，但會使處理後續異常困難，但無EndInvoke調用傳播。會發生什麼事是您的應用程序將最終得到TargetInvocationException。

Answer 2

我順多餘的委託聲明。

private void mCoolObject_CoolEvent(object sender, CoolObjectEventArgs args) 
{ 
    if (InvokeRequired) 
    { 
     Invoke(new Action<object, CoolObjectEventArgs>(mCoolObject_CoolEvent), sender, args); 
     return; 
    } 
    // do the dirty work of my method here 
} 

對於非事件，你可以使用System.Windows.Forms.MethodInvoker委託或System.Action。

編輯：此外，每個事件都有相應的EventHandler委託，因此根本不需要重新聲明一個委託。

Answer 3

我一直想知道它是多麼昂貴的總是假設，要求調用...

private void OnCoolEvent(CoolObjectEventArgs e) 
{ 
    BeginInvoke((o,e) => /*do work here*/,this, e); 
} 

Answer 4

您可以嘗試開發一些那種接受SynchronizationContext作爲輸入，並使用它來調用事件的通用組件。

Answer 5

作爲一個有趣的方面說明，WPF的綁定自動處理封送處理，因此您可以將UI綁定到在後臺線程上修改的對象屬性，而無需執行任何特殊操作。這已經證明對我來說是一個很好的節省時間。

在XAML：

<TextBox Text="{Binding Path=Name}"/> 

Answer 6

我有some code for this在線。它比其他建議好得多;絕對檢查出來。

使用範例：

private void mCoolObject_CoolEvent(object sender, CoolObjectEventArgs args) 
{ 
    // You could use "() =>" in place of "delegate"; it's a style choice. 
    this.Invoke(delegate 
    { 
     // Do the dirty work of my method here. 
    }); 
} 

Answer 7

我覺得最徹底的方法是絕對去AOP路線。創建幾個方面，添加必要的屬性，並且不必再次檢查線程關聯。

Answer 8

我做了以下「通用」跨線程調用類爲我自己的目的，但我認爲這是值得分享：

using System; 
using System.Collections.Generic; 
using System.Text; 
using System.Windows.Forms; 

namespace CrossThreadCalls 
{ 
    public static class clsCrossThreadCalls 
    { 
    private delegate void SetAnyPropertyCallBack(Control c, string Property, object Value); 
    public static void SetAnyProperty(Control c, string Property, object Value) 
    { 
     if (c.GetType().GetProperty(Property) != null) 
     { 
     //The given property exists 
     if (c.InvokeRequired) 
     { 
      SetAnyPropertyCallBack d = new SetAnyPropertyCallBack(SetAnyProperty); 
      c.BeginInvoke(d, c, Property, Value); 
     } 
     else 
     { 
      c.GetType().GetProperty(Property).SetValue(c, Value, null); 
     } 
     } 
    } 

    private delegate void SetTextPropertyCallBack(Control c, string Value); 
    public static void SetTextProperty(Control c, string Value) 
    { 
     if (c.InvokeRequired) 
     { 
     SetTextPropertyCallBack d = new SetTextPropertyCallBack(SetTextProperty); 
     c.BeginInvoke(d, c, Value); 
     } 
     else 
     { 
     c.Text = Value; 
     } 
    } 
    } 

而且你可以簡單地從另一個線程使用SetAnyProperty（）：

CrossThreadCalls.clsCrossThreadCalls.SetAnyProperty(lb_Speed, "Text", KvaserCanReader.GetSpeed.ToString()); 

在這個例子中，上面的KvaserCanReader類運行自己的線程，並調用主窗體上的lb_Speed標籤的text屬性。

Answer 9

如果要將結果發送到UI線程，請使用同步上下文。我需要改變線程優先級，所以我改變了使用線程池線程（註釋掉代碼）並創建了自己的新線程。我仍然可以使用同步上下文來返回數據庫是否成功取消。

#region SyncContextCancel 

    private SynchronizationContext _syncContextCancel; 

    /// <summary> 
    /// Gets the synchronization context used for UI-related operations. 
    /// </summary> 
    /// <value>The synchronization context.</value> 
    protected SynchronizationContext SyncContextCancel 
    { 
     get { return _syncContextCancel; } 
    } 

    #endregion //SyncContextCancel 

    public void CancelCurrentDbCommand() 
    { 
     _syncContextCancel = SynchronizationContext.Current; 

     //ThreadPool.QueueUserWorkItem(CancelWork, null); 

     Thread worker = new Thread(new ThreadStart(CancelWork)); 
     worker.Priority = ThreadPriority.Highest; 
     worker.Start(); 
    } 

    SQLiteConnection _connection; 
    private void CancelWork()//object state 
    { 
     bool success = false; 

     try 
     { 
      if (_connection != null) 
      { 
       log.Debug("call cancel"); 
       _connection.Cancel(); 
       log.Debug("cancel complete"); 
       _connection.Close(); 
       log.Debug("close complete"); 
       success = true; 
       log.Debug("long running query cancelled" + DateTime.Now.ToLongTimeString()); 
      } 
     } 
     catch (Exception ex) 
     { 
      log.Error(ex.Message, ex); 
     } 

     SyncContextCancel.Send(CancelCompleted, new object[] { success }); 
    } 

    public void CancelCompleted(object state) 
    { 
     object[] args = (object[])state; 
     bool success = (bool)args[0]; 

     if (success) 
     { 
      log.Debug("long running query cancelled" + DateTime.Now.ToLongTimeString()); 

     } 
    }