¿Cuál es la mejor solución para el problema de bloque de uso de cliente WCF `usando`?

e gusta crear instancias de mis clientes de servicio WCF dentro de unausing block ya que es más o menos la forma estándar de usar recursos que implementanIDisposable:

using (var client = new SomeWCFServiceClient()) 
{
    //Do something with the client 
}

Pero, como se señala eneste artículo de MSDN, envolviendo un cliente WCF en unusing block podría enmascarar cualquier error que provoque que el cliente quede en un estado defectuoso (como un tiempo de espera o un problema de comunicación). En pocas palabras, cuando se llama a Dispose (), el método Close () del cliente se dispara, pero arroja un error porque está en un estado defectuoso. La excepción original queda enmascarada por la segunda excepción. No está bien

a solución alternativa sugerida en el artículo de MSDN es evitar por completo el uso de unausing block, y en su lugar instanciar a sus clientes y usarlos de la siguiente manera:

try
{
    ...
    client.Close();
}
catch (CommunicationException e)
{
    ...
    client.Abort();
}
catch (TimeoutException e)
{
    ...
    client.Abort();
}
catch (Exception e)
{
    ...
    client.Abort();
    throw;
}

En comparación con elusing bloque, creo que es feo. Y mucho código para escribir cada vez que necesite un cliente.

Afortunadamente, encontré algunas otras soluciones, como esta en IServiceOriented. Empiezas con:

public delegate void UseServiceDelegate<T>(T proxy); 

public static class Service<T> 
{ 
    public static ChannelFactory<T> _channelFactory = new ChannelFactory<T>(""); 

    public static void Use(UseServiceDelegate<T> codeBlock) 
    { 
        IClientChannel proxy = (IClientChannel)_channelFactory.CreateChannel(); 
        bool success = false; 
        try 
        { 
            codeBlock((T)proxy); 
            proxy.Close(); 
            success = true; 
        } 
        finally 
        { 
            if (!success) 
            { 
                proxy.Abort(); 
            } 
        } 
     } 
} 

Que luego permite:

Service<IOrderService>.Use(orderService => 
{ 
    orderService.PlaceOrder(request); 
}); 

Eso no está mal, pero no creo que sea tan expresivo y fácil de entender como elusing bloque.

La solución que estoy tratando de usar actualmente, leí por primera vez en blog.davidbarret.net. Básicamente anula la @ del clienDispose() método donde sea que lo use. Algo como

public partial class SomeWCFServiceClient : IDisposable
{
    void IDisposable.Dispose() 
    {
        if (this.State == CommunicationState.Faulted) 
        {
            this.Abort();
        } 
        else 
        {
            this.Close();
        }
    }
}

Esto parece ser capaz de permitir elusing bloquee nuevamente sin el peligro de enmascarar una excepción de estado con falla.

Entonces, ¿hay alguna otra trampa que deba tener en cuenta al usar estas soluciones? ¿Alguien ha encontrado algo mejor?