Detección de muerte de clientes en contratos dúplex WCF

Question

Estoy tratando de construir un SOA donde los clientes pueden realizar consultas de larga duración en el servidor y el servidor responde mediante una devolución de llamada.

Me gustaría poder detectar si el cliente se desconecta (mediante el apagado iniciado por el usuario, la excepción no controlada o la pérdida de conectividad de red) para que el servidor pueda elegir cancelar la costosa solicitud.

Estoy probando una variedad de casos de falla, pero parece que no puedo hacer que se activen ciertos controladores de eventos.

Casos de falla probados: Matar el proceso del cliente después de la solicitud. Usando un programa como CurrPorts para cerrar la conexión TCP.

Código de prueba:

using System;
using System.ServiceModel;
using System.Threading;

namespace WCFICommunicationObjectExperiments
{
    class Program
    {
        static void Main(string[] args)
        {
            var binding = new NetTcpBinding(SecurityMode.None);

            var serviceHost = new ServiceHost(typeof (Server));
            serviceHost.AddServiceEndpoint(typeof (IServer), binding, "net.tcp://localhost:5000/Server");
            serviceHost.Open();
            Console.WriteLine("Host is running, press <ENTER> to exit.");
            Console.ReadLine();
        }

    }

    [ServiceContract(CallbackContract = typeof(IClient))]
    public interface IServer
    {
        [OperationContract]
        void StartProcessing(string Query);
    }

    public interface IClient
    {
        [OperationContract]
        void RecieveResults(string Results);
    }

    [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class Server : IServer
    {

        public void StartProcessing(string Query)
        {
            Thread.Sleep(5000);

            //Callback Channel
            var clientCallback = OperationContext.Current.GetCallbackChannel<IClient>();
            var clientCallbackCommunicationObject = ((ICommunicationObject) clientCallback);
            EventHandler faultedHandlerCallback = (o, s) => Console.WriteLine("Client Channel Faulted.");
            EventHandler closedHandlerCallback = (o, s) => Console.WriteLine("Client Channel Closed.");
            clientCallbackCommunicationObject.Faulted += faultedHandlerCallback;
            clientCallbackCommunicationObject.Closed += closedHandlerCallback;

            //Request Channel
            var requestChannel = OperationContext.Current.Channel;
            EventHandler faultedHandlerRequest = (o, s) => Console.WriteLine("Request Channel Faulted.");
            EventHandler closedHandlerRequest = (o, s) => Console.WriteLine("Request Channel Closed.");
            requestChannel.Faulted += faultedHandlerRequest;
            requestChannel.Closed += closedHandlerRequest;

            try
            {
                clientCallback.RecieveResults("42.");
            }
            catch (CommunicationObjectAbortedException ex)
            {
                Console.WriteLine("Client Aborted the connection");
            }
            catch (CommunicationObjectFaultedException ex)
            {
                Console.WriteLine("Client Died.");
            }
            clientCallbackCommunicationObject.Faulted -= faultedHandlerCallback;
            clientCallbackCommunicationObject.Faulted -= closedHandlerCallback;
            requestChannel.Faulted -= faultedHandlerRequest;
            requestChannel.Closed -= closedHandlerRequest;
        }
    }

    public class ClientToTestStates : IClient
    {
        private IServer m_Server;

        private readonly ManualResetEvent m_ReceivedEvent = new ManualResetEvent(false);
        private readonly ManualResetEvent m_ChannelFaulted = new ManualResetEvent(false);
        private readonly ManualResetEvent m_ChannelClosed = new ManualResetEvent(false);

        public ClientToTestStates()
        {
            var binding = new NetTcpBinding(SecurityMode.None);
            var channelFactory = new DuplexChannelFactory<IServer>(this, binding, new EndpointAddress("net.tcp://localhost:5000/Server"));
            m_Server = channelFactory.CreateChannel();
            ((ICommunicationObject)m_Server).Open();
            ((ICommunicationObject)m_Server).Faulted += ChannelFaulted;
            ((ICommunicationObject)m_Server).Closed += ChannelClosed;

            m_Server.StartProcessing("What is the answer?");

            WaitHandle.WaitAny(new WaitHandle[] {m_ReceivedEvent, m_ChannelFaulted, m_ChannelClosed});
        }

        void ChannelFaulted(object sender, EventArgs e)
        {
            m_ChannelFaulted.Set();
            Console.WriteLine("Channel Faulted.");
        }

        void ChannelClosed(object sender, EventArgs e)
        {
            m_ChannelClosed.Set();
            Console.WriteLine("Channel Closed.");
        }


        public void RecieveResults(string results)
        {
            m_ReceivedEvent.Set();
            Console.WriteLine("Recieved Results {0}", results);
        }
    }
}

¿Cuál es la mejor práctica para manejar este tipo de casos de falla? Me gustaría poder usar la conexión tcp subyacente para detectar algunas de estas cosas.

Answer 1

En su libro 'Programación de servicios WCF', Juval Lowy explica que WCF no proporciona un mecanismo para administrar devoluciones de llamadas de servicio, y esto debe ser administrado explícitamente por el servicio y el cliente. Si el servicio intenta invocar una devolución de llamada que se ha cerrado en el cliente, se lanzará una ObjectDisposedException en el canal de servicio.

Recomienda agregar un método de conexión y desconexión al contrato de servicio, ya que la devolución de llamada debe proporcionarse al servicio cuando se llama, el servicio puede administrar las devoluciones de llamadas del cliente. Depende del cliente asegurarse de que llame a Desconectar cuando ya no desee recibir devoluciones de llamada del servicio, y el servicio debe manejar cualquier excepción al invocar devoluciones de llamada al cliente.

Answer 2

intente esto para verificar si el objeto de devolución de llamada sigue siendo válido:

(((ICommunicationObject)myCallbackObject).State == CommunicationState.Opened)

myCallbackObject en este caso es el objeto a través del cual puede realizar la devolución de llamada, es decir, el que implementa el contrato de devolución de llamada