Асинхронно потребляет синхронную службу WCF

Ответ 1

Клиентская сторона и сторона сервера полностью отделены от асинхронной точки зрения, они вообще не заботятся друг о друге. У вас должна быть функция синхронизации на вашем сервере и только функция синхронизации на вашем сервере.

Если вы хотите сделать это "правильно", на клиенте вы не сможете повторно использовать один и тот же интерфейс для создания своего канала factory в качестве интерфейса, который используется для генерации сервера.

Итак, ваша сторона сервера будет выглядеть так:

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

Ответ 2

Если ваш API-интерфейс на стороне сервера может быть естественно асинхронным (например, ваш Task.Delay пример, а не Task.Run -сервер), объявите его как Task -ограниченный в интерфейсе контракта. В противном случае просто оставьте его синхронным (но не используйте Task.Run). Не создавайте несколько конечных точек для синхронных и асинхронных версий одного и того же метода.

Сгенерированный WSDL остается неизменным для асинхронных и синхронных API-интерфейсов, я только выяснил, что сам: Различные формы интерфейса контракта службы WCF. Ваши клиенты будут продолжать работать без изменений. Из-за того, что ваш серверный метод WCF асинхронен, все, что вы делаете, - это улучшение масштабируемости службы. Разумеется, это замечательная вещь, но упаковка синхронного метода с Task.Run скорее повредит масштабируемости, чем улучшит ее.

Теперь клиент вашей службы WCF не знает, реализован ли этот метод как синхронный или асинхронный на сервере, и ему не нужно это знать. Клиент может синхронно вызывать ваш метод (и блокировать поток клиента), или он может вызывать его асинхронно (без блокировки клиентского потока). В любом случае это не изменит тот факт, что ответное сообщение SOAP будет отправлено клиенту только, когда метод полностью завершится на сервере.

В ваш тестовый проект вы пытаетесь предоставить разные версии одного и того же 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 подробно объясняет это здесь. Подводя итог, не похоже, что служба WCF возвращает ваш клиент, чтобы уведомить об завершении операции async. Скорее, он просто отправляет полный ответ SOAP, используя базовый сетевой протокол, когда это делается. Если вам нужно больше, вы можете использовать обратные вызовы WCF для любых уведомлений от сервера к клиенту, но это будет охватывать границы одного SOAP.

Ответ 3

Это не ужасно: fooobar.com/info/277024/.... Вы просто переносите возвращаемые значения с помощью Task.FromResult(). Вы должны изменить службу, но она по-прежнему синхронна, и вы не используете дополнительный поток. Это изменяет интерфейс на стороне сервера, который по-прежнему может использоваться совместно с клиентом, поэтому он может ждать асинхронно. В противном случае, похоже, что вы должны каким-то образом поддерживать отдельные контракты на сервере и клиенте.