What WCF Exceptions should I retry on failure for? (such as the bogus 'xxx host did not receive a reply within 00:01:00')

I have a WCF client that has thrown this common error, just to be resolved with retrying the HTTP call to the server. For what it's worth this exception was not generated within 1 minute. It was generated in 3 seconds.

The request operation sent to xxxxxx did not receive a r开发者_开发问答eply within the configured timeout (00:01:00). 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. Please consider increasing the operation timeout (by casting the channel/proxy to IContextChannel and setting the OperationTimeout property) and ensure that the service is able to connect to the client

How are professionals handling these common WCF errors? What other bogus errors should I handle.

For example, I'm considering timing the WCF call and if that above (bogus) error is thrown in under 55 seconds, I retry the entire operation (using a while() loop). I believe I have to reset the entire channel, but I'm hoping you guys will tell me what's right to do.

What other

I make all of my WCF calls from a custom "using" statement which handles exceptions and potential retires. My code optionally allows me to pass a policy object to the statement so I can easily change the behavior, like if I don't want to retry on error.

The gist of the code is as follows:

[MethodImpl(MethodImplOptions.NoInlining)]
public static void ProxyUsing<T>(ClientBase<T> proxy, Action action)
    where T : class
{
    try
    {
        proxy.Open();
        using(OperationContextScope context = new OperationContextScope(proxy.InnerChannel))
        {
          //Add some headers here, or whatever you want
            action();
        }
    }
    catch(FaultException fe)
    {
      //Handle stuff here
    }
    finally
    {
        try
        {
            if(proxy != null
                && proxy.State != CommunicationState.Faulted)
            {
                proxy.Close();
            }
            else
            {
                proxy.Abort();
            }
        }
        catch
        {
            if(proxy != null)
            {
                proxy.Abort();
            }
        }
    }
}

You can then use the call like follows:

ProxyUsing<IMyService>(myService = GetServiceInstance(), () =>
{
    myService.SomeMethod(...);
});

The NoInlining call probably isn't important for you. I need it because I have some custom logging code that logs the call stack after an exception, so it's important to preserve that method hierarchy in that case.