内部具有多个异步调用的异步 WCF 服务

Question

我在 WCF 中有一个 Web 服务，它消耗一些外部 Web 服务，所以我想做的是使这个服务异步以释放线程，等待所有外部服务完成，然后返回结果给客户。

使用框架 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;
        }

    }
}

我的问题是：

1. 此代码使用三个线程：一个在 BeginDoWork，另一个在代码进入时被实例化的 匿名方法ContinueWhenAll里面，最后一个when 回调被执行，在本例中为 EndDoWork。这是正确的还是 我在通话中做错了什么？我应该使用任何 同步上下文？注意：同步上下文为空 在主线程上。

2. 如果我在两个人之间“共享”信息会发生什么 线程，例如回调函数？这会导致 性能问题或匿名方法就像我的闭包 可以共享数据吗？

使用 Framework 4.5 和 Async and Await

现在有了 Framework 4.5，代码似乎比以前简单多了：

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

但是在这种情况下，当我调试应用程序时，我总是看到代码是在同一个线程上执行的。所以我的问题是：

3.. 当我在等待“可等待”代码时，该线程是否被释放并返回线程池执行更多请求？

3.1。如果是这样，我想当我从等待任务中获得结果时，执行会在之前调用的同一线程上完成。那可能吗？如果该线程正在处理另一个请求会怎样？

3.2 如果不是，如何释放线程以将其发送回具有 Asycn 和 Await 模式的线程池？

谢谢！

Answer 1

1。此代码使用三个线程：一个在 BeginDoWork 中实例化，另一个在代码进入匿名方法 ContinueWhenAll 时实例化，最后一个在执行回调时实例化，在本例中为 EndDoWork。这是正确的还是我在通话中做错了什么？我应该使用任何同步上下文吗？

最好从“任务”而不是“线程”的角度来思考。您在这里确实有三个任务，每个任务都将在线程池上运行，一次一个。

2。如果我在线程之间“共享”信息会发生什么，例如回调函数？这会导致性能问题还是匿名方法就像我可以共享数据的闭包？

您不必担心同步问题，因为这些任务中的每一个都不能同时运行。 BeginDoWork 在返回之前注册延续，所以当延续可以运行时它实际上已经完成。 EndDoWork 可能在继续完成之前不会被调用；但即使是，它也会阻塞，直到继续完成。

（从技术上讲，延续可以在BeginDoWork 完成之前开始运行，但BeginDoWork 只是在那个时候返回，所以没关系）。

3。当我在等待“awaitable”代码时，该线程是否被释放并返回线程池执行更多请求？

是的。

3.1。如果是这样，我想当我从等待任务中获得结果时，执行会在之前调用的同一线程上完成。那可能吗？如果该线程正在处理另一个请求会怎样？

没有。您的主机（在本例中为 ASP.NET）可能会在它碰巧可用的任何线程上继续 async 方法。

这是非常安全的，因为一次只有一个线程在执行。

附：我推荐

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

而不是

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

因为在async 编程中应该避免使用Task.Result。