引發事件時，所有的異步方法調用完成

Question

我有以下問題： 在異步情況下，我需要初始化一些自定義對象的領域之前，我可以與它的其他操作的進行，所以我做的：

class ContainingObject 
{  
    private CustomObject _co; 

    SomeMethod() 
    { 
    _co = new CustomObject(); 
    _co.InitObjectAsyncCompleted += (s,e) => DoStuff(); 
    _co.InitObjectAsync(); 
    }  
} 

class CustomObject 
{ 
    public string Field1, Field2, Field3, Field4; 

    public EventHandler InitObjectAsyncCompleted; 

    public void InitObjectAsync() 
    { 
    }  
} 

問題在於字段也是通過對WCF服務的異步調用進行初始化的，並且在引發InitObjectAsyncCompleted事件之前，必須對所有字段進行初始化。 這裏有相當多的這些字段，每個字段都使用不同的WCF調用進行初始化，並且暗示我現在不能更改WCF部分，我看到了兩種方法來解決問題：

1）WCF鏈調用，調用初始化第一個字段，然後調用WCF初始化第二個字段，等所有字段初始化之前，然後我在最後一次WCF調用中引發「已完成」事件。

public void InitObjectAsync() 
{ 
    var proxy = new ProxyFactory.GetCustomObjectProxy; 
    proxy.GetDataForField1Completed += (s,e) => 
    { 
     Field1 = e.Result; 
     proxy.GetDataForField2Completed += (s1,e1) => 
     { 
      Field2 = e1.Result; 
      //keep this up building a chain of events, when Field4 is filled, raise 
      // InitObjectAsyncCompleted(this, null);   
     }; 
     proxy.GetDataForField2(); 
    }; 
    proxy.GetDataForField1(); 
} 

2）因爲我知道應該完成多少方法調用，在這種情況下，我可以做一個計數器。

public void InitObjectAsync() 
{ 
    int counter = 0; 
    var proxy = new ProxyFactory.GetCustomObjectProxy; 
    proxy.GetDataForField1Completed += (s,e) => 
    { 
     Field1 = e.Result; 
     if(counter >= 3) 
      InitObjectAsyncCompleted(this, null); 
     else 
      counter++; 
    }; 
    proxy.GetDataForField1(); 
    proxy.GetDataForField2Completed += (s,e) => 
    { 
     Field2 = e.Result; 
     if(counter >= 3) 
      InitObjectAsyncCompleted(this, null); 
     else 
      counter++; 
    }; 
    proxy.GetDataForField2(); 
    //repeat for all fields 
} 

我真的不喜歡任何解決方案，第一個建立事件的一個相當大的和非常可讀鏈，二是隻是...原油 - 任何人都可以提出解決這個問題的一個更優雅的方式？

Answer 1

第二種方法比第一種方法更容易理解，但兩種方法都有點脆弱。

一種替代方法是跟蹤未完成的初始化請求和完成的數量，並使用此信息來決定何時觸發事件。下面是我的意思的例子：

private int _outstandingRequests = 0; 

public void InitObjectAsync() 
{ 
    RequestField(proxy.GetDataForField1, 
        proxy.GetDataForField1Completed, 
        s => Field1 = s); 

    RequestField(proxy.GetDataForField2, 
        proxy.GetDataForField2Completed, 
        s => Field2 = s); 

    RequestField(proxy.GetDataForField3, 
        proxy.GetDataForField3Completed, 
        s => Field3 = s); 
    // ... and so on... 
} 

// This method accepts two actions and a event handler reference. 
// It composes a lambda to perform the async field assignment and internally 
// manages the count of outstanding requests. When the count drops to zero, 
// all async requests are finished, and it raises the completed event. 

private void RequestField<T>(Action fieldInitAction, 
           EventHandler fieldInitCompleteEvent, 
           Action<T> fieldSetter) 
{ 
    // maintain the outstanding request count... 
    _outstandingRequests += 1; 

    // setup event handler that responds to the field initialize complete   
    fieldInitCompleteEvent += (s,e) => 
    { 
     fieldSetter(e.Result); 

     _outstandingRequests -= 1; 

     // when all outstanding requests finish, raise the completed event 
     if(_outstandingRequests == 0) 
      RaiseInitCompleted(); 
    } 

    // call the method that asynchronously retrieves the field value... 
    fieldInitAction(); 
} 

private void RaiseInitCompleted() 
{ 
    var initCompleted = InitObjectAsyncCompleted; 
    if(initCompleted != null) 
     initCompleted(this, null); 
} 

Answer 2

如果您使用.NET 4.0的並行擴展，你可以創建多個異步任務，很容易加入他們的行列：

Task[] tasks = new Task[3] 
{ 
    Task.Factory.StartNew(() => MethodA()), 
    Task.Factory.StartNew(() => MethodB()), 
    Task.Factory.StartNew(() => MethodC()) 
}; 

//Block until all tasks complete. 
Task.WaitAll(tasks); 

Answer 3

把每個WCF調用在一個小包裝類。把這些類放在一個集合中（或者如果命令很重要，則列表），並且在通話結束時讓它們從集合中移除。他們還應該監視一個監視器。

Monitor.Enter。循環遍歷集合中的所有WCF調用。然後等待監視器。每次收到通知時，如果該集合不爲空，請等待。當你離開等待循環時，調用init並引發事件。如果你願意的話，你總是可以在Monitor.Wait上超時。（我經常打電話給我的鎖waitingRoom，所以很明顯發生了什麼）。

如果你將自己從WCF調用中分離出來，你就等待着，那麼這個方法很好也很容易測試，你可以做任何事情，比如記錄任何WCF調用，通過包裝類識別它失敗。