Manejar al cliente WCF persistente ingresando el estado fallado

Question

Tenemos un servicio WCF que estamos consumiendo desde una aplicación web. El cliente que estamos utilizando se generó utilizando la opción "Agregar referencia de servicio" de Visual Studio. Dado que es una aplicación web, y dado que la naturaleza de la aplicación es probable que conduzca a sesiones relativamente cortas, hemos optado por crear una instancia del cliente cuando un usuario inicia sesión y lo mantiene durante toda la sesión, luego maneje su eliminación cuando la sesión haya terminado.

Esto me lleva a mi pregunta: estamos tratando de decidir la mejor manera de manejar el canal del cliente entrando en un estado Faulted. Después de buscar en torno a algunos, que hemos llegado con esto:

if(client.State = CommuncationState.Faulted) 
{ 
    client = new Client(); 
} 

try 
{ 
    client.SomeMethod(); 
} 
catch //specific exceptions left out for brevity 
{ 
    //logging or whatever we decide to do 
    throw; 
} 

Esto, sin embargo, no funciona debido al hecho de que, al menos en nuestro caso, incluso si el servicio se ha reducido el cliente mostrará el Open estado hasta que realmente intenta hacer una llamada que lo usa, en ese momento entra en el estado Faulted.

Esto nos deja para hacer otra cosa. Otra opción que se nos ocurrió fue:

try 
{ 
    client.SomeMethod(); 
} 
catch 
{ 
    if(client.State == CommunicationState.Faulted) 
    { 
     //we know we're faulted, try it again 
     client = new Client(); 
     try 
     { 
      client.SomeMethod(); 
     } 
     catch 
     { 
      throw; 
     } 
    } 
    //handle other exceptions 
} 

Pero eso huele mal. Obviamente, podríamos evitar esto usando un nuevo cliente y disponiéndolo para cada llamada. Parece innecesario, pero si es el camino correcto, entonces supongo que eso es lo que optaremos. Entonces, ¿cuál es la mejor manera de manejar con elegancia si el cliente está en un estado de falla y luego hacer algo al respecto? ¿De verdad deberíamos obtener un nuevo cliente para cada llamada?

Otra cosa a tener en cuenta: la creación de instancias del cliente y todas estas comprobaciones y gestiones se realizan en una clase contenedora para el cliente. Si hacemos esto de la forma en que lo intentamos, es transparente para la aplicación en sí misma: realizar llamadas y manejar excepciones de ellas no requiere ningún código especial allí.

Answer 1

Para responder a su pregunta, puede manejar el Faulted event de la propiedad ChannelFactory así:

client.ChannelFactory.Faulted += new EventHandler(ChannelFactory_Faulted); 

que debe permitir llevar a cabo cualquier explotación y/o de limpieza que lo que necesita hacer.

Como recomendación general, no debe dejar el canal abierto mientras dure la sesión, por lo tanto, asegúrese de cerrar correctamente el canal (cancelando la excepción) después de que haya terminado con el mismo.

Además, si es posible, considere NO utilizar Visual Studio Add Service Reference, o al menos limpiar el código/config que genera.Recomiendo que, si desea utilizar una implementación de proxy, cree la suya derivando de ClientBase, o use una implementación de ChannelFactory. Como mencionas una clase contenedora, te recomendaría que uses ChannelFactory y manejes el Faulted event para tus necesidades de limpieza.

Answer 2

Trate de controlar el evento .Faulted en el proxy de cliente, por ejemplo:

((ICommunicationObject)client).Faulted += new EventHandler(client_Faulted); 

private void client_Faulted(object sender, EventArgs e) 
{ 
    client = new Client(); 
    ((ICommunicationObject)client).Faulted += new EventHandler(client_Faulted); 
} 

Debe activar el instante en que los fallos de la vía, que le da la oportunidad de volver a abrirlo.

También debería ajustar cada llamada a un método client en un bloque try-catch, y quizás incluso envolverlo en un bucle while() que reintenta la llamada n veces, luego registra un error. EG:

bool succeeded = false; 
int triesLeft = 3; 
while (!succeeded && triesLeft > 0) 
{ 
    triesLeft--; 
    try 
    { 
     client.SomeMethod(); 
     succeeded = true; 
    } 
    catch (exception ex) 
    { 
     logger.Warn("Client call failed, retries left: " + triesLeft; 
    } 
} 
if (!succeeded) 
    logger.Error("Could not call web service"); 

En mi código que he ido tan lejos como para usar un ManualResetEvent para bloquear el bucle while() hasta que el manejador client_Faulted evento ha tenido la oportunidad de volver a crear el proxy client.