WCF-异步服务是否可互操作

Question

基本上，正如问题所述，如果我使服务异步，是否意味着它们不再可互操作？

Answer 1

就客户端而言，同步或异步版本的服务是相同的（请参阅下面的示例）。因此，同步/异步决策不会影响互操作性。

public class StackOverflow_6231864_751090
{
    [ServiceContract(Name = "ITest")]
    public interface ITest
    {
        [OperationContract]
        string Echo(string text);
        [OperationContract]
        int Add(int x, int y);
    }
    [ServiceContract(Name = "ITest")]
    public interface ITestAsync
    {
        [OperationContract(AsyncPattern = true)]
        IAsyncResult BeginEcho(string text, AsyncCallback callback, object state);
        string EndEcho(IAsyncResult ar);
        [OperationContract(AsyncPattern = true)]
        IAsyncResult BeginAdd(int x, int y, AsyncCallback callback, object state);
        int EndAdd(IAsyncResult ar);
    }
    public class Service : ITest
    {
        public string Echo(string text) { return text; }
        public int Add(int x, int y) { return x + y; }
    }
    public class ServiceAsync : ITestAsync
    {
        string Echo(string text) { return text; }
        int Add(int x, int y) { return x + y; }
        public IAsyncResult BeginEcho(string text, AsyncCallback callback, object state)
        {
            Func<string, string> func = Echo;
            return func.BeginInvoke(text, callback, state);
        }
        public string EndEcho(IAsyncResult ar)
        {
            Func<string, string> func = (Func<string, string>)((System.Runtime.Remoting.Messaging.AsyncResult)ar).AsyncDelegate;
            return func.EndInvoke(ar);
        }
        public IAsyncResult BeginAdd(int x, int y, AsyncCallback callback, object state)
        {
            Func<int, int, int> func = Add;
            return func.BeginInvoke(x, y, callback, state);
        }
        public int EndAdd(IAsyncResult ar)
        {
            Func<int, int, int> func = (Func<int, int, int>)((System.Runtime.Remoting.Messaging.AsyncResult)ar).AsyncDelegate;
            return func.EndInvoke(ar);
        }
    }
    public static void Test()
    {
        foreach (bool useAsync in new bool[] { false, true })
        {
            Type contractType = useAsync ? typeof(ITestAsync) : typeof(ITest);
            Type serviceType = useAsync ? typeof(ServiceAsync) : typeof(Service);
            Console.WriteLine("Using {0} service implementation", useAsync ? "Asynchronous" : "Synchronous");
            string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
            ServiceHost host = new ServiceHost(serviceType, new Uri(baseAddress));
            host.AddServiceEndpoint(contractType, new BasicHttpBinding(), "");
            host.Open();
            Console.WriteLine("Host opened");
            Console.WriteLine("Using the same client for both services...");
            ChannelFactory<ITest> factory = new ChannelFactory<ITest>(new BasicHttpBinding(), new EndpointAddress(baseAddress));
            ITest proxy = factory.CreateChannel();
            Console.WriteLine(proxy.Echo("Hello"));
            Console.WriteLine(proxy.Add(3, 4));
            ((IClientChannel)proxy).Close();
            factory.Close();
            host.Close();
            Console.WriteLine("Done");
            Console.WriteLine();
        }
    }
}

Answer 2

如果"使服务异步"是指使用AsyncPattern，那么我的理解是，这对客户端根本没有影响，只对WCF运行时如何调用服务器上的操作有影响。客户端（也就是WCF客户端）一如既往地自己选择是否使用异步调用。

来自此MSDN页面：

要定义异步执行的合约操作X，无论在客户端应用程序中如何调用它。。。

和：

在这种情况下，异步操作以与同步操作相同的形式公开在元数据中：它公开为具有请求消息和相关响应消息的单个操作。然后，客户端编程模型可以进行选择。它们可以将此模式表示为同步操作或异步操作，只要在调用服务时发生请求-响应消息交换即可。

Answer 3

您的服务不必做任何"特别"的事情。。。他们仍然以同样的方式行事。另一方面，客户端必须使用异步模式来使用服务。最简单的方法是使用"添加服务引用…"。只需选中一个写着"生成异步操作"的小框，瞧，你就可以对你的服务进行异步调用。。。

这里有一个很好的资源：如何：异步调用WCF服务操作

尽管有负面评论，但最后的例子写得很好。只需订阅<服务名称>完成事件，然后进行异步调用。调用完成后，您的UI线程将被释放，一旦调用完成，就会引发事件！小心你新发现的力量！

public class Foo
{
    private BarServiceClient client;
    public Foo()
    {
        client = new BarServiceClient();
        client.DoWorkCompleted += Client_DoWorkCompleted;
    }
    private void Client_DoWorkCompleted(object sender, DoWorkCompletedEventArgs e)
    {
        //e.Result contains your result.
    }
    public void DoBar()
    {
        client.DoWorkAsync(); //Called asynchronously, UI thread is free! :)
    }
}