C# Silverlight WCF: Thread Safe Multiple Async Call Strategy With Final Operation To Join Data.

Posted by OmegaMan at April 24, 2011

Category: C#, Silverlight, Threading

Tags: , , , ,

Seven Pointing Arrows ending at different points except one arror leaping of the page to show the final Async call.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 

    // 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
                .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"));

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);

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>();


            //Release the lock
            Interlocked.Exchange(ref AsyncErrorResource, 0);
        assignTo = receivedData;

    Interlocked.Decrement(ref PendingAsyncOperations);
    if (PendingAsyncOperations == 0)
        if (0 == Interlocked.Exchange(ref AsyncFinal, 1))

        Interlocked.Exchange(ref AsyncFinal, 0);
        Interlocked.Decrement(ref PendingAsyncOperations); // Move to -1
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. Smile 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)));
    // Success Handle accordingly.


  1. Duane says

    Great posting as I’m new at this.

    What do you need to do if your WCF calls needs to submit arguments?

    Would it look like this (based on your example)?


  2. Duane says

    I ended up replacing MultipleAsyncRun(DataContext.GetAccountsAsync(“XYZ”));
    and performed the actions manually:

    Interlocked.Increment(ref PendingAsynOperations);

    This whole thing works GREAT!!!! Thanks a lot!

    • OmegaMan says

      Where I am using this, I haven’t had the need for variables, til now…so I will probably be updating this post soon. Thanks for your work around in the time being.

  3. Aleah says

    Have you updated this yet to allow service calls with parameters?

    • OmegaMan says

      Hi Aleah,

      Here is the code to do a call with any variable

      public void MultipleAsyncRun<T>(Action<T> Operation, T value)
      Interlocked.Increment(ref PendingAsyncOperations);

      And it can be called like:

      MultipleAsyncRun(DataContext.GetManagementGroup, "Primary");

  4. Aleah says

    If I’m gonna do it that way I kind of need it to be more generic I guess. I’m actually doing a service call sometimes with 1 variable (company name) and sometimes with 2 (first name last name) for a custom autocomplete box that actually works propertly with silverlight, wcf, and mvvm. So what I did was I added a

    public void ManualMultipleAsyncRun()
    Interlocked.Increment(ref PendingAsyncOperations);

    Which I call from my viewmodel.

    ObservableCollection persons = BusinessEngine.ClaimsEntry.SearchPeopleByName(firstName, lastName); _callerAsyncSearch.AssignResultCheckforAllAsyncsDone(persons, ref _callerSearchResults, “Error occurred while searching.”);

    Also because of the way we handle service calls ina business engine in the BAL I had to create a slightly modified AssignResultCheckForAllAsyncsDone to take my results, my private viewmodel variable to hold results and an exception string.

    It works great!! Thanks for the help

  5. Nita L. Young says

    Great posting .What do you need to do if your WCF calls needs to submit arguments?

  6. Machal says

    ****ing nice, thanks Man 🙂 Sentance enhancer censored by editor. 🙂

  7. cdavid says

    Great solution. Thank you for posting it.

    Nita L. Young asked what one could do if parameters were required. I would do the following:

    MultipleAsyncRun(() => AsyncCallWithArgs(“Arg1”, arg2);

  8. cdavid says

    One thing I noticed that might be an issue is that you are adding individual actions such as:

    // Start the Async processes

    It is theoretically possible for the first call to complete before the second one is even added. What that would mean is that GetUserRequestsAsync is called and completes and then your FinalAsync is called, but not all of your data has been retrieved.

    I’ve created a version of the method that allows you to add multiple actions in one call so that I am assured that all of the actions are being counted before any of them is done.

    public void MultipleAsyncRun(IEnumerable actions)
    // Increment the number of calls
    Interlocked.Add(ref PendingAsyncOperations, actions.Count());

    // Call each of the actions in the list
    actions.ForEach((a) => a());

    I use it like so:

    MultipleAsyncRun(new Action[] {
    () => DoAction1Async(someArg),
    () => DoAction2Async(someOtherArg),


    Would love to get some feedback on this approach.


Leave a comment

(required) (will not be published)

This site uses Akismet to reduce spam. Learn how your comment data is processed.