如何为WCF客户端实现超时自动重试机制？

针对你基于System.ServiceModel.ClientBase<TChannel>的SOAP客户端重试需求，以下是几种无需显式包装调用、更贴合WCF架构的实现方案：

方案1：封装带Polly重试的基类客户端 #

创建一个抽象基类继承ClientBase<TChannel>，将重试逻辑封装在通用执行方法中，子类客户端只需调用该方法即可自动应用重试，完全避免显式的RetryOnTimeout写法。

public abstract class RetryableClientBase<TChannel> : ClientBase<TChannel> where TChannel : class
{
    private readonly AsyncRetryPolicy _asyncRetryPolicy;
    private readonly RetryPolicy _syncRetryPolicy;

    protected RetryableClientBase()
    {
        // 定义重试策略：针对TimeoutException和非业务异常的CommunicationException
        var policyBuilder = Policy
            .Handle<TimeoutException>()
            .Or<CommunicationException>(ex => ex is not FaultException);

        _asyncRetryPolicy = policyBuilder.WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        _syncRetryPolicy = policyBuilder.WaitAndRetry(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)));
    }

    protected async Task<TResult> ExecuteWithRetryAsync<TResult>(Func<TChannel, Task<TResult>> operation)
    {
        return await _asyncRetryPolicy.ExecuteAsync(async () =>
        {
            // 检查通道状态，故障则重建
            if (State == CommunicationState.Faulted)
            {
                Abort();
                InitializeChannel();
            }
            return await operation(Channel);
        });
    }

    protected TResult ExecuteWithRetry<TResult>(Func<TChannel, TResult> operation)
    {
        return _syncRetryPolicy.Execute(() =>
        {
            if (State == CommunicationState.Faulted)
            {
                Abort();
                InitializeChannel();
            }
            return operation(Channel);
        });
    }
}

子类客户端使用示例：

public class MySoapClient : RetryableClientBase<IMySoapService>, IMySoapService
{
    public async Task<MyResponse> GetDataAsync(MyRequest request)
    {
        return await ExecuteWithRetryAsync(channel => channel.GetDataAsync(request));
    }

    public MyResponse GetData(MyRequest request)
    {
        return ExecuteWithRetry(channel => channel.GetData(request));
    }
}

该方案的核心是将重试逻辑下沉到基类，业务代码完全无需感知重试细节，符合你对“正确方案”的预期。

方案2：自定义可重试的通道工厂 #

若不想通过基类继承，可自定义ChannelFactory子类，将重试逻辑集成到工厂的执行方法中：

public class RetryableChannelFactory<TChannel> : ChannelFactory<TChannel> where TChannel : class
{
    private readonly AsyncRetryPolicy _asyncRetryPolicy;

    public RetryableChannelFactory()
    {
        _asyncRetryPolicy = Policy
            .Handle<TimeoutException>()
            .Or<CommunicationException>(ex => ex is not FaultException)
            .WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)));
    }

    public async Task<TResult> ExecuteWithRetryAsync<TResult>(Func<TChannel, Task<TResult>> operation)
    {
        return await _asyncRetryPolicy.ExecuteAsync(async () =>
        {
            using var channel = CreateChannel() as IClientChannel;
            try
            {
                return await operation((TChannel)channel);
            }
            finally
            {
                if (channel.State == CommunicationState.Faulted)
                    channel.Abort();
                else
                    channel.Close();
            }
        });
    }
}

使用时直接通过工厂调用服务方法：

var factory = new RetryableChannelFactory<IMySoapService>();
var response = await factory.ExecuteWithRetryAsync(channel => channel.GetDataAsync(request));

不推荐的方案：IEndpointBehavior + IClientMessageInspector #

虽然可以通过消息拦截器拦截发送前后的请求，但WCF通道的状态管理是硬伤——一旦通道进入故障状态，拦截器无法安全重建通道，极易导致后续调用失败，实现复杂度远高于上述两种方案，因此不建议采用。

关键注意事项 #

• 排除业务异常：重试策略要过滤FaultException，这类异常是服务端返回的业务错误，无需重试。
• 通道状态管理：WCF通道在超时或通信故障后会进入Faulted状态，必须调用Abort()终止后重新初始化，否则无法继续使用。
• 指数退避策略：示例中使用指数退避等待时间，避免短时间内大量重试压垮服务端，可根据实际需求调整重试次数和等待逻辑。

内容的提问来源于stack exchange，提问作者br3nt