异步消费同步 WCF 服务

Question

我目前正在将客户端应用程序迁移到 .NET 4.5 以使用 async/await。该应用程序是当前仅提供同步服务的 WCF 服务的客户端。我现在想知道，我应该如何异步消费这个同步服务？

我正在使用channel factories 连接到 WCF 服务，利用服务器和客户端之间共享的服务合同。因此，我无法使用 VisualStudio 或 svcutil 的自动生成功能来生成异步客户端代理。

我读过this related question，它是关于是否使用Task.Run 在客户端包装同步调用，或者是否使用异步方法扩展服务合同。答案表明，由服务器提供“真正的”异步方法对客户端性能更好，因为没有线程必须主动等待服务调用完成。这对我来说确实很有意义，这意味着同步调用应该包装在服务器端。

另一方面，Stephen Toub 在this blog post 中普遍反对这样做。现在，他在那里没有提到 WCF，所以我不确定这是否仅适用于在同一台机器上运行的库，或者它是否也适用于远程运行的东西，但异步性的引入对连接/传输。

毕竟，由于服务器实际上并没有异步工作（而且很可能不会再有一段时间），一些线程将总是需要等待：无论是在客户端还是在服务器上。这也适用于同步使用服务时（当前，客户端等待后台线程以保持 UI 响应）。

示例

为了让问题更清楚，我准备了一个例子。完整的项目可用于download here。

服务器提供同步服务GetTest。这是目前存在的，也是工作发生的地方——同步。一种选择是将其包装在异步方法中，例如使用Task.Run，并将该方法作为合同中的附加服务提供（需要扩展合同接口）。

// currently available, synchronous service
public string GetTest() {
    Thread.Sleep(2000);
    return "foo";
}

// possible asynchronous wrapper around existing service
public Task<string> GetTestAsync() {
    return Task.Run<string>(() => this.GetTest());
}

// ideal asynchronous service; not applicable as work is done synchronously
public async Task<string> GetTestRealAsync() {
    await Task.Delay(2000);
    return "foo";
}

现在，在客户端，此服务是使用通道工厂创建的。这意味着我只能访问服务契约定义的方法，尤其是我无法访问异步服务方法，除非我明确定义和实现它们。

根据现在可用的方法，我有两种选择：

1. 我可以通过包装调用来异步调用同步服务：

   await Task.Run<string>(() => svc.GetTest());
   

2. 我可以直接异步调用服务器提供的异步服务：

   await svc.GetTestAsync();
   

两者都可以正常工作，并且不会阻止客户端。这两种方法都涉及到某个端的忙等待：选项 1 在客户端等待，这相当于之前在后台线程中所做的。选项 2 通过将同步方法包装在那里等待服务器。

使同步 WCF 服务异步感知的推荐方法是什么？我应该在哪里执行包装，在客户端还是在服务器上？或者有没有更好的选择来做到这一点而无需在任何地方等待，即通过在连接上引入“真正的”异步——就像生成的代理一样？

Answer 1

从异步的角度来看，客户端和服务器端是完全分开的，它们根本不关心彼此。您的服务器上应该有同步功能，并且只有服务器上的同步功能。

如果您想“正确”地执行此操作，则在客户端上，您将无法重复使用与用于生成服务器的接口相同的接口来生成通道工厂。

所以你的服务器端看起来像这样

using System.ServiceModel;
using System.Threading;

namespace WcfService
{
    [ServiceContract]
    public interface IService
    {
        [OperationContract]
        string GetTest();
    }

    public class Service1 : IService
    {
        public string GetTest()
        {
            Thread.Sleep(2000);
            return "foo";
        }
    }
}

你的客户端看起来像这样

using System;
using System.Diagnostics;
using System.ServiceModel;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace SandboxForm
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            var button = new Button();
            this.Controls.Add(button);

            button.Click += button_Click;
        }

        private async void button_Click(object sender, EventArgs e)
        {
            var factory = new ChannelFactory<IService>("SandboxForm.IService"); //Configured in app.config
            IService proxy = factory.CreateChannel();

            string result = await proxy.GetTestAsync();

            MessageBox.Show(result);
        }
    }

    [ServiceContract]
    public interface IService
    {
        [OperationContract(Action = "http://tempuri.org/IService/GetTest", ReplyAction = "http://tempuri.org/IService/GetTestResponse")]
        Task<string> GetTestAsync();
    }
}

Answer 2

如果您的服务器端 API自然 可以异步（例如您的 Task.Delay 示例，而不是 Task.Run 包装器），请在合约接口中将其声明为基于 Task。否则，让它保持同步（但不要使用Task.Run）。不要为同一方法的同步和异步版本创建多个端点。

对于异步和同步合约 API，生成的 WSDL 保持不变，我自己刚刚发现：Different forms of the WCF service contract interface。您的客户将保持不变。通过使您的服务器端 WCF 方法异步，您所做的就是提高服务的可伸缩性。当然，这是一件很棒的事情，但是用 Task.Run 包装一个同步方法会损害可伸缩性而不是改进它。

现在，您的 WCF 服务的客户端不知道该方法是在服务器上实现为同步还是异步，并且它不需要知道这一点。客户端可以同步调用您的方法（并阻塞客户端的线程），也可以异步调用它（不阻塞客户端的线程）。在任何一种情况下，都不会改变 SOAP 响应消息将仅在服务器上完全完成该方法时发送到客户端的事实。

在your test project 中，您试图以不同的合约名称公开同一 API 的不同版本：

[ServiceContract]
public interface IExampleService
{
    [OperationContract(Name = "GetTest")]
    string GetTest();

    [OperationContract(Name = "GetTestAsync")]
    Task<string> GetTestAsync();

    [OperationContract(Name = "GetTestRealAsync")]
    Task<string> GetTestRealAsync();
}

这实际上没有任何意义，除非您想为您的客户端提供一个选项来控制该方法是在服务器上同步运行还是异步运行。 我不明白为什么你会想要这个，但即使你有你的理由，你最好还是通过方法参数和 API 的单一版本来控制它：

[ServiceContract]
public interface IExampleService
{
    [OperationContract]
    Task<string> GetTestAsync(bool runSynchronously);
}

然后，在实现中你可以这样做：

Task<string> GetTestAsync(bool runSynchronously)
{
    if (runSynchronously)
        return GetTest(); // or return GetTestAsyncImpl().Result;
    else
        return await GetTestAsyncImpl();
}

@usr 详细解释了这一点here。综上所述，它不类似于 WCF 服务回调您的客户端以通知异步操作的完成。相反，它只是在完成后使用底层网络协议发回完整的 SOAP 响应。如果您需要更多，您可以将WCF callbacks 用于任何服务器到客户端的通知，但这会跨越单个 SOAP 消息的边界。

Answer 3

这并不可怕：https://stackoverflow.com/a/23148549/177333。你只需用Task.FromResult() 包装你的返回值。您必须更改服务端，但它仍然是同步的，并且您没有使用额外的线程。这会改变您仍然可以与客户端共享的服务器端接口，因此它可以异步等待。否则看起来你必须以某种方式在服务器和客户端上维护单独的合同。