c# - WCF NamedPipes 服务和 WPF 客户端

Question

我正在使用一个 Windows 服务，我也想在其中添加一个 GUI。我通过我的服务创建一个 ServiceHost 对象并托管 WCF 命名管道服务进行了概念验证，然后我使用控制台应用程序来使用 WCF 服务并从该服务获取回调响应(从服务器发送到连接的客户端的消息)。这非常有效，我的控制台应用程序运行并从服务获得响应，没有中断或延迟。

但是，当在我的 WPF GUI 应用程序中执行相同的操作时，当单击一个按钮然后调用 WCF 服务时，它会卡住整个 UI 线程，然后在几分钟后引发异常，然后 UI 会使用消息回调进行更新(服务器向连接的客户端发送消息)但是由于抛出异常，来自服务的任何返回值都丢失了。

我得到的两个异常消息是论文(最常见的是第一个):

1: 发送到 net.pipe://localhost/PipeGUI 的请求操作在指定的超时时间 (00:00:59.9989999) 内未收到响应。分配给此操作的时间可能是较长超时的一部分。这可能是因为服务仍在处理操作，或者因为服务无法发送回复消息。提高操作的截止日期(通过输入 channel /代理到图标文本 channel 并设置属性操作超时)并验证服务是否可以连接到客户端。

2:通信对象System.ServiceModel.Channels.ServiceChannel，已取消，不能用于通信

有人知道为什么会这样吗？如果需要，我可以发布更多代码。

UPDATE，添加代码供引用

public interface IClientCallback
{
    [OperationContract(IsOneWay = true)]
    void MessageRecived(string message);
}

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IClientCallback))]
public interface IPipeServiceContract
{
    [OperationContract]
    string Hello();

    [OperationContract]
    void Message(string msg);

    [OperationContract(IsInitiating = true)]
    void Connect();

    [OperationContract(IsTerminating = true)]
    void Disconnect();
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, IncludeExceptionDetailInFaults = true, UseSynchronizationContext = false)]
public class PipeService : IPipeServiceContract
{
    List<IClientCallback> _clients = new List<IClientCallback>();

    public string Hello()
    {
        PublishMessage("Hello World.");
        return "Return from method!";
    }

    public void Connect()
    {
        _clients.Add(OperationContext.Current.GetCallbackChannel<IClientCallback>());
    }

    public void Disconnect()
    {
        IClientCallback callback = OperationContext.Current.GetCallbackChannel<IClientCallback>();
        _clients.Remove(callback);
    }

    void PublishMessage(string message)
    {
        for (int i = _clients.Count - 1; i > 0; i--)
        {
            try
            {
                _clients[i].MessageRecived(message);
            }
            catch (CommunicationObjectAbortedException coae)
            {
                _clients.RemoveAt(i);
            }
            catch(CommunicationObjectFaultedException cofe)
            {
                _clients.RemoveAt(i);
            }
        }
    }


    public void Message(string msg)
    {
        PublishMessage(msg);
    }
}


/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window, INotifyPropertyChanged, IClientCallback
{
    public ServiceController Service { get; set; }

    protected IPipeServiceContract Proxy { get; set; }
    protected DuplexChannelFactory<IPipeServiceContract> PipeFactory { get; set; }

    public ObservableCollection<ServerActivityNotification> Activity { get; set; }

    public override void BeginInit()
    {
        base.BeginInit();
        PipeFactory = new DuplexChannelFactory<IPipeServiceContract>(this, new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/PipeGUI"));
    }

    public MainWindow()
    {
        InitializeComponent();
        Activity = new ObservableCollection<ServerActivityNotification>();
        Service = ServiceController.GetServices().First(x => x.ServiceName == "Server Service");
        NotifyPropertyChanged("Service");
        var timer = new DispatcherTimer();
        timer.Tick += new EventHandler(OnUpdate);
        timer.Interval = new TimeSpan(0, 0, 0, 0, 850);
        timer.Start();

        if (Service.Status == ServiceControllerStatus.Running)
        {
            Proxy = PipeFactory.CreateChannel();
            Proxy.Connect();
        }
    }

    void OnUpdate(object sender, EventArgs e)
    {
        Service.Refresh();
        NotifyPropertyChanged("Service");

        StartButton.IsEnabled = Service.Status != ServiceControllerStatus.Running ? true : false;
        StopButton.IsEnabled = Service.Status != ServiceControllerStatus.Stopped ? true : false;

        if (PipeFactory != null && Service.Status == ServiceControllerStatus.Running)
        {
            Proxy = PipeFactory.CreateChannel();
            Proxy.Connect();
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public void NotifyPropertyChanged(string name)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(name));
    }

    private void OnStart(object sender, RoutedEventArgs e)
    {
        try
        {
            Service.Start();
        }
        catch
        {
            Service.Refresh();
        }
    }

    private void OnStop(object sender, RoutedEventArgs e)
    {
        try
        {
            if (Proxy != null)
            {
                Proxy.Disconnect();
                PipeFactory.Close();
            }
            Service.Stop();
        }
        catch
        {
            Service.Refresh();
        }
    }

    public void MessageRecived(string message)
    {
        Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
        {
            ServerActivityNotification log = new ServerActivityNotification { Activity = message, Occured = DateTime.Now };
            Activity.Add(log);
            ListBoxLog.ScrollIntoView(log);
            NotifyPropertyChanged("Activity");
        }));
    }

    private void OnHello(object sender, RoutedEventArgs e)
    {
        try
        {
            Proxy.Message(txtSendMessage.Text);
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
    }
}

Answer 1

尝试将服务行为的 UseSynchronizationContext 属性设置为 false:

[ServiceBehavior(UseSynchronizationContext = false)]
class MyService
{

}

[ServiceContract]
public interface IMyService
{

}

我相信默认情况下它设置为 true，因此您当前正试图在同一线程上使用和运行 WCF 服务，从而导致死锁。

无论如何，听起来您正试图在 WPF 应用程序的 UI 线程上使用 WCF 服务。通常建议您在后台线程上执行可能长时间运行的任务，因为这样即使您的服务调用需要几秒/分钟，也能保持界面响应。

编辑:

我尝试并成功地重现了您的问题。尝试调用 UI 线程上的服务会导致 UI 卡住。但是，当我更改代码以在后台任务中调用服务时(见下文)，我能够调用该服务并接收回调:

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        Task.Factory.StartNew(() =>
            {
                var myService = DuplexChannelFactory<IMyService>.CreateChannel(new CallbackImplementation(),
                                                                               new WSDualHttpBinding(),
                                                                               new EndpointAddress(
                                                                                   @"http://localhost:4653/myservice"));
                myService.CallService();
                string s = "";
            });
    }

我必须承认，我不完全确定为什么会这样，任何关于 WCF 究竟如何管理托管服务实例的线程的澄清都将有助于弄清楚为什么会这样。