Question

I have a web service in WCF that consume some external web services, so what I want to do is make this service asynchronous in order to release the thread, wait for the completion of all the external services, and then return the result to the client.

With Framework 4.0

public class MyService : IMyService
{
    public IAsyncResult BeginDoWork(int count, AsyncCallback callback, object serviceState)
    {    
        var proxyOne = new Gateway.BackendOperation.BackendOperationOneSoapClient();
        var proxyTwo = new Gateway.BackendOperationTwo.OperationTwoSoapClient();

        var taskOne = Task<int>.Factory.FromAsync(proxyOne.BeginGetNumber, proxyOne.EndGetNumber, 10, serviceState);
        var taskTwo = Task<int>.Factory.FromAsync(proxyTwo.BeginGetNumber, proxyTwo.EndGetNumber, 10, serviceState);
        
        var tasks = new Queue<Task<int>>();
        tasks.Enqueue(taskOne);
        tasks.Enqueue(taskTwo);

        return Task.Factory.ContinueWhenAll(tasks.ToArray(), innerTasks =>
        {
            var tcs = new TaskCompletionSource<int>(serviceState);
            int sum = 0;

            foreach (var innerTask in innerTasks)
            {
                if (innerTask.IsFaulted)
                {
                    tcs.SetException(innerTask.Exception);
                    callback(tcs.Task);
                    return;
                }

                if (innerTask.IsCompleted)
                {
                    sum = innerTask.Result;
                }
            }

            tcs.SetResult(sum);

            callback(tcs.Task);
        });
    }

    public int EndDoWork(IAsyncResult result)
    {
        try
        {
            return ((Task<int>)result).Result;
        }
        catch (AggregateException ex)
        {
            throw ex.InnerException;
        }

    }
}

My questions here are:

1. This code is using three threads: one that is instanced in the
   BeginDoWork, another one that is instanced when the code enter
   inside the anonymous method ContinueWhenAll, and the last one when
   the callback is executed, in this case EndDoWork. Is that correct or
   I’m doing something wrong on the calls? Should I use any
   synchronization context? Note: The synchronization context is null
   on the main thread.

2. What happen if I “share” information between
   threads, for instance, the callback function? Will that cause a
   performance issue or the anonymous method is like a closure where I
   can share data?

With Framework 4.5 and Async and Await

Now with Framework 4.5, the code seems too much simple than before:

    public async Task<int> DoWorkAsync(int count)
    {
        var proxyOne = new Backend.ServiceOne.ServiceOneClient();
        var proxyTwo = new Backend.ServiceTwo.ServiceTwoClient();

        var doWorkOne = proxyOne.DoWorkAsync(count);
        var doWorkTwo = proxyTwo.DoWorkAsync(count);

        var result = await Task.WhenAll(doWorkOne, doWorkTwo);

        return doWorkOne.Result + doWorkTwo.Result;
    }

But in this case when I debug the application, I always see that the code is executed on the same thread. So my questions here are:

3.. When I’m waiting for the “awaitable” code, is that thread released and goes back to the thread pool to execute more requests?

3.1. If So, I suppose that when I get a result from the await Task, the execution completes on the same thread that the call before. Is that possible? What happen if that thread is processing another request?

3.2 If Not, how can I release the thread to send it back to the thread pool with Asycn and Await pattern?

Thank you!

Answer 1

1. This code is using three threads: one that is instanced in the BeginDoWork, another one that is instanced when the code enter inside the anonymous method ContinueWhenAll, and the last one when the callback is executed, in this case EndDoWork. Is that correct or I’m doing something wrong on the calls? Should I use any synchronization context?

It’s better to think in terms of “tasks” rather than “threads”. You do have three tasks here, each of which will run on the thread pool, one at a time.

2. What happen if I “share” information between threads, for instance, the callback function? Will that cause a performance issue or the anonymous method is like a closure where I can share data?

You don’t have to worry about synchronization because each of these tasks can’t run concurrently. BeginDoWork registers the continuation just before returning, so it’s already practically done when the continuation can run. EndDoWork will probably not be called until the continuation is complete; but even if it is, it will block until the continuation is complete.

(Technically, the continuation can start running before BeginDoWork completes, but BeginDoWork just returns at that point, so it doesn’t matter).

3. When I’m waiting for the “awaitable” code, is that thread released and goes back to the thread pool to execute more requests?

Yes.

3.1. If So, I suppose that when I get a result from the await Task, the execution completes on the same thread that the call before. Is that possible? What happen if that thread is processing another request?

No. Your host (in this case, ASP.NET) may continue the async methods on any thread it happens to have available.

This is perfectly safe because only one thread is executing at a time.

P.S. I recommend

var result = await Task.WhenAll(doWorkOne, doWorkTwo);
return result[0] + result[1];

instead of

var result = await Task.WhenAll(doWorkOne, doWorkTwo);
return doWorkOne.Result + doWorkTwo.Result;

because Task.Result should be avoided in async programming.