This article describes one way to handle asynchronous or async calls in .Net 3.5 or .Net 4.0 when using WCF in Silverlight in C#. The goal is to have a final operation wait for all the calls to finish so to combine all the data gathered, all in a thread safe way. A secondary goal is to minimize the consumer code required to perform this operation from what is currently available in straight WCF async calls.
This article has a short shelf life because after .Net 4 (see What’s Next in C#? Get Ready for Async!) one will use the built in Asynchrony methodology developed. Until that time if one is using any version of Silverlight and WCF then this article describes how to handle those multiple async calls and join the data in a final method call.
Final Result Example
Before delving into the solution, here is how the consumer will use the methodology. Below a user is getting account information of user requests, departments and accounts to join all the data on the view model in the final method for display on a Silverlight page. Thesee operations as shown are setup when the view model class (MyViewModel) is created and no blocking occurs keeping UI thread clear.
public MyViewModel()
{
DataContext = new MyServiceClient();
FinalAsync(CombineDataAndDisplay); // When all the data is retrieved, do this method to combine the data From the 3 async callls below
// Provide the operation as a lambda (could be a method call) to assign data to our target backing store property
// and if all has gone well (no errors in other async calls) and it is the final completing operation. Do the final
// Processing call automatically.
DataContext.GetUserRequestsCompleted += (s, e) => { AssignResultCheckforAllAsyncsDone(e, e.Result, ref _UserRequests, "Acquisition failure for User Requests");};
DataContext.GetAccountsCompleted += (s, e) => { AssignResultCheckforAllAsyncsDone(e, e.Result, ref _Accounts, "Acquisition Failure for Accounts"); };
DataContext.GetDepartments += (s, e) => { AssignResultCheckforAllAsyncsDone(e, e.Result, ref _Departments, "Failed to get Department Info."); };
// Start the Async processes
MultipleAsyncRun(DataContext.GetUserRequestsAsync);
MultipleAsyncRun(DataContext.GetAccountsAsync);
MultipleAsyncRun(DataContext.GetDepartmentsAsync);
// Exit out and return the UI thread to the user operations.
}
// Once all the data is done, combine and assign into our
// PagedCollectionView property for display on the screen.
public void CombineDataAndDisplay()
{
// Combine missing data on the calls
_UserRequests.ToList()
.ForEach(ur =>
{
ur.BillingName = _Accounts.First(ac => ur.AccountID == ac.AccountID).Name;
ur.DepartmentName = _Departments.First(dp => dp.DepartmentID == ur.DepartmentID).Name;
});
UserRequests = new PagedCollectionView( _UserRequests);
UserRequests.GroupDescriptions.Add(new PropertyGroupDescription("DepartmentName"));
}
| Explanation |
| Line 5: |
The final async call is where this process specifies a method to use after all async calls are completed. On line 24 of the example is our final operation method to do that which is reported to FinalAsync. |
| Line 11-13: |
Just like the normal async process we subscribe to the anync handler but we handle it in a anonymous lambda. |
| Line 11-13: |
AssignResultCheckForAllAsyncsDone method will check the result returned, code show later in the article. All one needs to know now is that the respective _UserRequests, _Accounts and _Departments, all backing store variables (not properties) will be loaded with the data if the result information ( e ) operation contains no errors. This method does all the heavy lifiting by checking error state, loading the data variable, decrementing the async count and firing off the final method if all asynchronous operations are completed. |
| Line 16-18: |
Just like the normal WCF async process we must launch the asnc calls and these statements do just that. We supply the method to be launched inside the MulipleAsync method. |
| Line 24: |
Here is our final method to be executed once the asynchrony process is complete. This method combines all the async data internally into the _UserRequest object at which it becomes complete and can be used. |
| Line 34: |
Finally a paged collection view is created from our data to be bound to Silverlight Xaml items which is our end result. |
| 24-37: |
Note: The section below has a variable entitled AsyncErrors. The above example did not check that for null or an error situation. I have left out the check of AsyncErrors for brevity of the example. See the last section for an example of proper error handling. |
Multiple Async Methodology Plumbing
Below is what will needed to be brought into your View Model, or placed on your page if not using MVVM. This is where the .Net thread safe Silverlight asynchronous operations will occur.
// Lock Objects 0 for false, 1 for true.
private int AsyncErrorResource = 0;
private int AsyncFinal = 0;
private List<Exception> AsyncErrors; // If not null errors have been encountered.
private int PendingAsyncOperations; // Holds the counted total of ongoing async operations. Zero means do users final operation.
private Action FinalOperation; // The user's final operation.
public void MultipleAsyncRun(Action Operation)
{
Interlocked.Increment(ref PendingAsyncOperations);
Operation();
}
public void FinalAsync(Action method)
{
FinalOperation = method;
}
public void AssignResultCheckforAllAsyncsDone<T>(AsyncCompletedEventArgs ea, T receivedData, ref T assignTo, string ErrorMessage)
where T : class
{
bool valid = !((ea.Error != null) || (receivedData == null));
if (valid == false)
{
if (0 == Interlocked.Exchange(ref AsyncErrorResource, 1))
{
if (AsyncErrors == null)
AsyncErrors = new List<Exception>();
AsyncErrors.Add(ea.Error);
//Release the lock
Interlocked.Exchange(ref AsyncErrorResource, 0);
}
}
else
{
assignTo = receivedData;
}
Interlocked.Decrement(ref PendingAsyncOperations);
if (PendingAsyncOperations == 0)
{
if (0 == Interlocked.Exchange(ref AsyncFinal, 1))
{
FinalOperation();
}
Interlocked.Exchange(ref AsyncFinal, 0);
Interlocked.Decrement(ref PendingAsyncOperations); // Move to -1
}
}
| Explanation |
| Line 2/3: |
These variables are used as a lock targets for thread safety. Value zero means its open and a value of 1 means a lock is in place. |
| Line 5: |
Any errors encountered are placed into AsyncErrors. The final operation must check this variable. If it is not null errors have occurred and data is incomplete see the final section of this article on how to handle errors. |
| Line 7: |
This variable will hold the running total async operations. Once it gets to zero the final operation will be executed. |
| Line 11: |
This method counts and stores our async operations as they come in and launches the async method as well. |
| Line 13: |
This process uses the Interlocked class found in the System.Threading namespace. To quote Microsoft, “Provides atomic operations for variables that are shared by multiple threads. “. We simply count up the PendingAsyncOperations variable. Later when the operations complete this will be decremented. |
| Line 18: |
This method is called by the consumer so we know what method to launch when all async operations have completed. We assign the method to a holder variable as found on line 9. |
| Line 22: |
This method will take in the event arguments and check if there is a problem. It will store the error if there is one and also decrement our count. If our count hits zero it will launch the users final operation. |
|
| 25-39: |
Checking errors reported by the async call. If there are any we log them and do not assign the variable. Note whether an error exists or not the operation continues below where the final operation is checked for and executed. Its up to the final operation to check if errors exists and handle them appropriately. |
| Line 42: |
If the event reports a success this is where we assign the value to the passed in reference to the template T assignTo. If one doesn’t use a variable for assignTo reference an exception will be generated on this line. See the following section as to why. |
| Line 46: |
We safely decrement our operations count variable. Zero means we are done! |
| Line 47-57: |
Here is where we execute the final operation when the count is zero. Note there is an extra lock if operations unlikely hit a zero at the same time. The extra lock ensures only one will execute the final method. |
That is it, simply use the above code and you can have all your operations work done asynchronously. 
Now for the disclaimers…
Why Can’t Properties be Used by AssignResultCheckforAllAsyncsDone?
We must use direct variables like in our example
private ObservableCollection<UserRequestDTO> _UserRequests;
private ObservableCollection<Account> _Accounts;
private ObservableCollection<Department> _Deparments;
// Not Private ObservableCollection<Department> _Departments { get; set; }
If one used a property this exception is thrown.
A property, indexer or dynamic member access may not be passed as an out or ref parameter
That is because we are using the generic method AssignResultCheckforAllAsyncsDone to assign a value, and that assignment has to have an exact object instance for the template (T) object and not a Property to assign the value. If your end result is in a property, simply assign it from the variable to the property in the final async call.
Handling Errors
Simply check the error variable if it is not null it has encountered errors.
if (AsyncErrors != null)
{
MessageBox.Show("Errors: " + string.Join(string.Format("{0}{0}", Environment.NewLine), AsyncErrors.Select(ex => ex.Message)));
}
else
{
// Success Handle accordingly.
}
