工业通信可靠性：Polly重试机制在.NET中的应用

1. 工业上位机网络通信的可靠性挑战

在工业自动化领域，上位机系统经常需要与各类外部系统进行网络通信交互。典型的场景包括向企业微信推送报警信息、通过Modbus/OPC UA协议读写设备数据、将采集数据写入数据库以及调用各类API接口等。然而工业现场的网络环境往往存在诸多不稳定因素：

• 车间WiFi信号波动导致短暂断连
• 设备总线负载高峰造成通信延迟
• 服务器端接口偶发性超时
• 协议转换网关的间歇性故障

这些网络问题如果处理不当，会导致关键数据丢失、控制指令失效等严重后果。传统解决方案通常采用简单的while循环重试，但这种方式存在以下缺陷：

1. 缺乏科学的退避策略，容易造成网络拥塞
2. 无法区分不同类型的异常进行差异化处理
3. 重试逻辑与业务代码高度耦合
4. 难以实现灵活的重试策略配置

2. Polly重试机制的核心价值

Polly是一个.NET生态中广泛使用的弹性瞬态故障处理库，特别适合解决工业通信中的间歇性故障问题。其核心优势体现在：

2.1 策略组合的灵活性

Polly支持将多种策略组合使用：

• 重试（Retry）：基础重试逻辑
• 断路器（Circuit Breaker）：防止持续失败
• 超时（Timeout）：避免长时间等待
• 回退（Fallback）：失败后的替代方案

2.2 工业场景适配特性

• 支持指数退避算法，避免网络风暴
• 可配置异常白名单，针对特定错误重试
• 提供同步/异步两种编程模型
• 内置丰富的执行统计信息

2.3 典型工业通信故障处理

csharp复制// 典型Modbus通信异常处理配置
var retryPolicy = Policy
    .Handle<ModbusIOException>()
    .Or<TimeoutException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
        onRetry: (exception, delay, retryCount, context) => 
            logger.Warning($"Modbus通信重试中... 次数:{retryCount} 延迟:{delay.TotalSeconds}s"));

3. 企业微信消息推送的完整实现方案

3.1 企业微信机器人接口封装

首先需要封装企业微信Webhook的基础调用：

csharp复制public class WeComRobotClient
{
    private readonly HttpClient _httpClient;
    private readonly string _webhookUrl;

    public WeComRobotClient(string webhookUrl)
    {
        _httpClient = new HttpClient();
        _webhookUrl = webhookUrl;
    }

    public async Task<HttpResponseMessage> SendTextMessageAsync(string content)
    {
        var message = new {
            msgtype = "text",
            text = new {
                content = content
            }
        };
        
        return await _httpClient.PostAsJsonAsync(_webhookUrl, message);
    }
}

3.2 Polly策略的深度配置

针对企业微信接口特性配置复合策略：

csharp复制var policy = Policy.WrapAsync(
    // 超时控制
    Policy.TimeoutAsync(TimeSpan.FromSeconds(10)), 
    
    // 重试策略
    Policy.Handle<HttpRequestException>()
        .OrResult<HttpResponseMessage>(r => 
            (int)r.StatusCode >= 500 || r.StatusCode == HttpStatusCode.RequestTimeout)
        .WaitAndRetryAsync(
            sleepDurations: new[]
            {
                TimeSpan.FromSeconds(1),
                TimeSpan.FromSeconds(3),
                TimeSpan.FromSeconds(5)
            },
            onRetry: (outcome, delay, retryCount, context) => 
            {
                // 记录重试日志
                var statusCode = outcome.Result?.StatusCode.ToString() ?? outcome.Exception.Message;
                logger.Warning($"企业微信推送重试 #{retryCount}，状态:{statusCode}");
            }),
            
    // 断路器
    Policy.Handle<HttpRequestException>()
        .CircuitBreakerAsync(
            exceptionsAllowedBeforeBreaking: 5,
            durationOfBreak: TimeSpan.FromMinutes(5))
);

3.3 策略执行与业务集成

将策略应用到实际业务逻辑中：

csharp复制public class AlarmService
{
    private readonly WeComRobotClient _robotClient;
    private readonly IAsyncPolicy _policy;

    public AlarmService(WeComRobotClient robotClient, IAsyncPolicy policy)
    {
        _robotClient = robotClient;
        _policy = policy;
    }

    public async Task SendAlarmAsync(string alarmMessage)
    {
        try 
        {
            await _policy.ExecuteAsync(async () => 
            {
                var response = await _robotClient.SendTextMessageAsync(alarmMessage);
                response.EnsureSuccessStatusCode();
            });
        }
        catch (Exception ex)
        {
            logger.Error($"报警消息发送最终失败: {ex.Message}");
            // 可在此处添加备用通知渠道
        }
    }
}

4. Modbus/OPC UA通信的重试实现

4.1 Modbus通信的特殊处理

Modbus协议通信需要特别考虑以下异常情况：

csharp复制var modbusPolicy = Policy
    .Handle<ModbusIOException>()
    .Or<Modbus.SlaveException>()
    .Or<SocketException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromMilliseconds(200 * attempt),
        onRetry: (ex, delay) => 
            logger.Warning($"Modbus设备响应异常，{delay.TotalMilliseconds}ms后重试..."));

// 使用示例
public async Task<ushort[]> ReadHoldingRegistersAsync(byte slaveId, ushort startAddress, ushort numberOfPoints)
{
    return await modbusPolicy.ExecuteAsync(async () => 
    {
        using var master = _modbusFactory.CreateMaster(_serialPort);
        return await master.ReadHoldingRegistersAsync(slaveId, startAddress, numberOfPoints);
    });
}

4.2 OPC UA的会话管理策略

OPC UA通信需要处理会话中断等复杂场景：

csharp复制var opcUaPolicy = Policy.WrapAsync(
    Policy.Handle<ServiceResultException>(ex => 
        ex.StatusCode == StatusCodes.BadSessionClosed ||
        ex.StatusCode == StatusCodes.BadConnectionClosed)
    .RetryAsync(
        retryCount: 1,
        onRetry: async (ex, retryCount) => 
        {
            logger.Warning("OPC UA会话异常，尝试重建连接...");
            await _opcUaClient.ReconnectAsync();
        }),
        
    Policy.TimeoutAsync(TimeSpan.FromSeconds(15))
);

5. 数据库写入的可靠性保障

5.1 数据库特定的重试策略

针对SQL数据库的瞬态故障：

csharp复制var sqlPolicy = Policy.Handle<SqlException>(ex => 
        ex.Number == -2 ||  // 超时
        ex.Number == 53 ||   // 连接失败
        ex.Number == 121)    // 死锁
    .Or<TimeoutException>()
    .WaitAndRetryAsync(
        sleepDurations: new[]
        {
            TimeSpan.FromSeconds(1),
            TimeSpan.FromSeconds(2),
            TimeSpan.FromSeconds(4)
        },
        onRetry: (ex, delay) => 
            logger.Warning($"数据库操作失败，{delay.TotalSeconds}s后重试..."));

// 使用示例
public async Task LogDataAsync(DeviceData data)
{
    await sqlPolicy.ExecuteAsync(async () => 
    {
        using var conn = new SqlConnection(_connectionString);
        await conn.ExecuteAsync(
            "INSERT INTO DeviceLog VALUES (@Timestamp, @Value)", 
            data);
    });
}

5.2 批量操作的特殊处理

对于批量数据插入，建议采用分块重试策略：

csharp复制var bulkInsertPolicy = Policy.Handle<SqlException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(attempt));

public async Task BulkInsertDataAsync(IEnumerable<DeviceData> data)
{
    // 将数据分块处理
    var chunks = data.Chunk(1000);
    
    foreach (var chunk in chunks)
    {
        await bulkInsertPolicy.ExecuteAsync(async () => 
        {
            using var conn = new SqlConnection(_connectionString);
            await conn.ExecuteAsync(
                "INSERT INTO DeviceLog VALUES (@Timestamp, @Value)", 
                chunk);
        });
    }
}

6. 策略配置的最佳实践

6.1 策略参数的工业场景调优

根据不同的工业场景需求调整策略参数：

6.2 策略的生命周期管理

推荐采用依赖注入方式管理策略实例：

csharp复制// 策略注册
services.AddSingleton<IAsyncPolicy<HttpResponseMessage>>(sp => 
    Policy.WrapAsync(
        GetTimeoutPolicy(),
        GetRetryPolicy(),
        GetCircuitBreakerPolicy()
    ));

// 业务类中使用
public class DataSyncService
{
    private readonly IAsyncPolicy<HttpResponseMessage> _policy;

    public DataSyncService(IAsyncPolicy<HttpResponseMessage> policy)
    {
        _policy = policy;
    }
    
    // ...业务方法使用_policy执行操作
}

7. 监控与诊断实现

7.1 策略执行日志记录

通过Polly的onRetry等回调记录详细执行情况：

csharp复制var policy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(attempt),
        onRetry: (ex, delay, attempt, context) => 
        {
            logger.Warning($"重试事件 - 操作:{context.OperationKey} " +
                         $"次数:{attempt} 延迟:{delay.TotalMilliseconds}ms " +
                         $"异常:{ex.GetType().Name}");
            
            // 记录到监控系统
            _telemetryClient.TrackEvent("PollyRetry", new Dictionary<string, string>
            {
                ["operation"] = context.OperationKey,
                ["attempt"] = attempt.ToString(),
                ["exception"] = ex.GetType().Name
            });
        });

7.2 策略性能指标收集

通过Polly.Context收集运行时指标：

csharp复制// 执行时传入上下文
var context = new Context
{
    ["startTime"] = DateTime.UtcNow,
    ["operation"] = "ModbusRead"
};

await policy.ExecuteAsync(ctx => 
    DoModbusOperationAsync(), 
    context);

// 在onRetry/onBreak等回调中可以访问上下文

8. 常见问题与解决方案

8.1 策略执行中的典型问题

1. 重试风暴问题

   • 现象：多个实例同时重试导致服务端压力激增
   • 解决方案：采用随机化退避时间

   csharp复制.WaitAndRetryAsync(3, attempt => 
       TimeSpan.FromSeconds(attempt) + 
       TimeSpan.FromMilliseconds(new Random().Next(0, 500)))
   

2. 上下文传递丢失

   • 现象：异步调用链中上下文信息丢失
   • 解决方案：使用AsyncLocal保存上下文

   csharp复制public static class ExecutionContext
   {
       private static readonly AsyncLocal<Dictionary<string, object>> _state = new();
       
       public static IDictionary<string, object> Current => 
           _state.Value ??= new Dictionary<string, object>();
   }
   

3. 策略组合冲突

   • 现象：多个策略相互影响产生意外行为
   • 解决方案：明确策略执行顺序

   csharp复制// 正确的策略组合顺序
   var policy = Policy.WrapAsync(
       fallbackPolicy,
       circuitBreakerPolicy,
       timeoutPolicy,
       retryPolicy
   );
   

8.2 工业场景特殊考量

1. 设备响应超时设置

   • PLC设备通常需要较长的响应时间
   • 建议：Modbus RTU超时设置在300-500ms范围

2. 网络隔离环境适配

   • 厂区内网可能需要代理配置

   csharp复制var httpClient = new HttpClient(
       new HttpClientHandler 
       { 
           Proxy = new WebProxy("http://plant-proxy:8080")
       });
   

3. 安全认证处理

   • OPC UA证书需要特殊管理

   csharp复制var opcUaPolicy = Policy
       .Handle<ServiceResultException>(ex => 
           ex.StatusCode == StatusCodes.BadCertificateInvalid)
       .RetryOnceAsync(async (ex, ctx) => 
           await _certificateManager.RenewCertificateAsync());
   

9. 性能优化技巧

9.1 策略缓存与复用

避免频繁创建策略实例：

csharp复制// 静态策略缓存
public static class PolicyCache
{
    private static readonly ConcurrentDictionary<string, IAsyncPolicy> _policies = new();
    
    public static IAsyncPolicy GetOrAdd(string key, Func<IAsyncPolicy> policyFactory)
    {
        return _policies.GetOrAdd(key, _ => policyFactory());
    }
}

// 使用方式
var policy = PolicyCache.GetOrAdd("WeComRetry", () => 
    Policy.Handle<HttpRequestException>()
        .WaitAndRetryAsync(/*...*/));

9.2 轻量级策略执行

对于高频操作优化策略开销：

csharp复制// 使用PolicyWrap的轻量级方式
var quickRetry = Policy.Handle<TimeoutException>()
    .RetryAsync(1);  // 快速重试1次

var fullPolicy = Policy.WrapAsync(
    quickRetry,
    standardRetryPolicy
);

9.3 策略的热重载

支持运行时策略调整：

csharp复制public class ReloadablePolicy
{
    private IAsyncPolicy _currentPolicy;
    private readonly object _lock = new object();
    
    public void UpdatePolicy(Func<IAsyncPolicy> policyBuilder)
    {
        lock (_lock)
        {
            _currentPolicy = policyBuilder();
        }
    }
    
    public async Task<T> ExecuteAsync<T>(Func<Task<T>> action)
    {
        IAsyncPolicy policy;
        lock (_lock)
        {
            policy = _currentPolicy;
        }
        return await policy.ExecuteAsync(action);
    }
}

10. 扩展应用场景

10.1 与工业4.0平台集成

将重试机制应用于IIoT平台通信：

csharp复制var iiotPolicy = Policy.WrapAsync(
    Policy.Handle<MqttCommunicationException>()
        .WaitAndRetryAsync(/*...*/),
        
    Policy.Handle<EdgeHubCommunicationException>()
        .CircuitBreakerAsync(/*...*/)
);

// 遥测数据上传
public async Task UploadTelemetryAsync(TelemetryData data)
{
    await iiotPolicy.ExecuteAsync(async () => 
    {
        await _edgeHubClient.SendEventAsync("telemetry", data);
    });
}

10.2 多级降级策略实现

构建完整的容错体系：

csharp复制var resilientStrategy = Policy.WrapAsync(
    fallbackPolicy,        // 最终回退
    cachePolicy,          // 本地缓存
    circuitBreakerPolicy, // 熔断保护
    bulkheadPolicy,       // 隔离舱
    timeoutPolicy,        // 超时控制
    retryPolicy           // 基础重试
);

10.3 跨服务事务补偿

处理分布式场景下的数据一致性：

csharp复制var compensationPolicy = Policy.Handle<Exception>()
    .FallbackAsync(
        fallbackAction: async (ctx, ct) => 
        {
            await _compensationService.CompensateAsync(ctx["txId"].ToString());
        },
        onFallbackAsync: async (ex, ctx) => 
        {
            logger.Error($"操作失败，已触发补偿: {ex.Message}");
        });