WCF NamedPipes服务和WPF客户端

Question

I'm working with a windows service where i want to add a GUI too it. I made a proof of concept with my service creating a ServiceHost object and hosting the WCF Named pipes service and then i Console application to consume the WCF service and also getting callback responses from the service (messages sent from server to connected clients). This works great my console application runs and get responses from the service with no interruption or delays.

However when doing the same thing in my WPF GUI application when clicking a button that then calls the WCF service it freezes the whole UI thread and then after a couple of minutes throws an exception and then the UI is updated with the message callback (server sends message to connected clients) but any return values from service is lost since the exception was thrown.

The two exception messages i have gothen is theses (the most common is the first):

1: The requesting action sent to net.pipe :/ / localhost / PipeGUI did not receive a response within the specified timeout (00:00:59.9989999). The time allotted to this operation may have been a portion of a longer timeout. This may be because the service is still processing the operation or because the service was unable to send a reply message. Raise the deadline for action (by entering the channel / proxy to Icon Text Channel and set the property Operation Timeout) and verify that the service can connect to the client.

2: Communication object System.ServiceModel.Channels.ServiceChannel, can not be used for communication because it has been canceled.

Anyone got any ideas why this is happeing ? I can post more code if neccessary.

UPDATE , added code for reference

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

Try setting the UseSynchronizationContext property of the service behaviour to false :

[ServiceBehavior(UseSynchronizationContext = false)]
class MyService
{

}

[ServiceContract]
public interface IMyService
{

}

I believe that by default this is set to true , so you are currently attempting to consume and run the WCF service on the same thread resulting in a deadlock.

In any case, it sounds like you are trying to consume the WCF service on the UI thread of the WPF application. Generally it is recommended that you perform potentially long running tasks on the background thread as this keeps the interface responsive even if your service call takes a few seconds/minutes.

EDIT:

I tried and succeeded in replicating your problem. Trying to call the service on the UI thread results in the UI freezing. However, when I changed my code to call the service on a background task (see below), I was able to call the service and receive the callback:

    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 = "";
            });
    }

I have to confess, I am not entirely sure why this is so, and any clarification on exactly how WCF manages the thread hosting the service instance would be great in working out why this works.