1

我在 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 时实例化，最后一个在执行回调时实例化，在本例中为 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.. 当我在等待“awaitable”代码时，该线程是否被释放并返回线程池执行更多请求？

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

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

谢谢！

4

1 回答 1

2

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

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

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

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

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

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

是的。

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

不会。您的主机（在本例中为 ASP.NET）可以async在它碰巧可用的任何线程上继续执行这些方法。

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

PS我推荐

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

代替

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

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

于 2012-07-19T19:52:02.367 回答