Polly 是一个为 .NET 应用程序提供弹性和瞬时故障处理的库。通过使用 Polly，你可以非常简洁地实现重试、断路器、超时和缓存等功能，以增强应用程序的健壮性和稳定性。

本文将详细介绍如何在 C# 项目中使用 Polly，并通过多个示例展示其使用方法。

目录

1. 安装 Polly
2. 基本使用
   • 重试策略
   • 断路器策略
   • 超时策略
   • 回退策略
   • 缓存策略
3. 综合示例

安装 Polly

首先，你需要在项目中安装 Polly 库。在 NuGet 包管理器控制台执行以下命令：

PowerShell
Install-Package Polly

或者在 Visual Studio 中，可以通过 NuGet 包管理器直接搜索 Polly 并安装。

基本使用

重试策略

重试策略用于在发生失败时自动重试操作。以下是一个简单的重试示例，它将在操作失败时重试三次：

C#
static void Main()
{
    // 重试三次
    var retryPolicy = Policy
        .Handle<Exception>()
        .Retry(3, (exception, retryCount) => {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

    try
    {
        retryPolicy.Execute(() => SimulateError());
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Operation failed after retries. Exception: {ex.Message}");
    }
}

// 抛出一个错误
static void SimulateError()
{
    Console.WriteLine("Simulating error...");
    throw new InvalidOperationException("Simulated exception.");
}

增加间隔1少重试

C#
static void Main()
{
    // 重试三次，每次间隔 1 秒
    var retryPolicy = Policy
        .Handle<Exception>()
        .WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(1), (exception, timeSpan, retryCount, context) => {
            Console.WriteLine($"Retry {retryCount} after {timeSpan.Seconds} seconds due to {exception.Message}");
        });

    try
    {
        retryPolicy.Execute(() => SimulateError());
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Operation failed after retries. Exception: {ex.Message}");
    }
}

// 抛出一个错误
static void SimulateError()
{
    Console.WriteLine("Simulating error...");
    throw new InvalidOperationException("Simulated exception.");
}

WaitAndRetry 方法参数：

• 第一个参数 3 表示重试三次。
• 第二个参数是一个函数，返回每次重试的延迟时间，在这里我们设定为 1 秒。
• 第三个参数是重试时执行的操作。在这个例子中，我们记录了重试的次数和异常消息。

断路器策略

断路器策略用于防止连续失败的影响，并在一段时间后恢复操作。以下是一个简单的断路器示例：

C#
static void Main()
{
    var circuitBreakerPolicy = Policy
        .Handle<Exception>()
        .CircuitBreaker(2, TimeSpan.FromSeconds(5),
            onBreak: (ex, breakDelay) => {
                Console.WriteLine($"Circuit broken due to {ex.Message}. Break delay: {breakDelay.TotalSeconds} seconds");
            },
            onReset: () => {
                Console.WriteLine("Circuit reset.");
            });

    for (int i = 0; i < 5; i++)
    {
        //这里try必要的
        try
        {
            circuitBreakerPolicy.Execute(() => SimulateError(i));
        }
        catch (Exception ex)
        {
            
        }
        // 等待1秒，方便观察断路器状态变化
        System.Threading.Thread.Sleep(1000);
    }
}

static void SimulateError(int attempt)
{
    Console.WriteLine($"Attempt {attempt}");
    throw new InvalidOperationException("Simulated exception.");
}

超时策略

超时策略用于限制操作的最长执行时间。以下是一个简单的超时示例：

C#
using Polly;
using System;
using System.Threading;

class Program
{
    static void Main()
    {
        var timeoutPolicy = Policy
            .Timeout(3, Polly.Timeout.TimeoutStrategy.Pessimistic, 
                onTimeout: (context, span, task) => {
                    Console.WriteLine($"Operation timed out after {span.TotalSeconds} seconds.");
                });

        try
        {
            timeoutPolicy.Execute(() => SimulateLongOperation());
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Operation failed. Exception: {ex.Message}");
        }
    }

    static void SimulateLongOperation()
    {
        Console.WriteLine("Starting long operation...");
        Thread.Sleep(5000);  // Simulate long running operation
        Console.WriteLine("Operation finished.");
    }
}

• Policy.Timeout：创建一个超时策略，设置超时时间为 3 秒。策略类型为悲观模式（Pessimistic）。
  • 3：表示操作的超时时间为 3 秒。
  • Polly.Timeout.TimeoutStrategy.Pessimistic：使用悲观超时策略。悲观超时策略在操作过期后立即抛出超时异常，并且可能会强制终止操作。
  • onTimeout 回调：定义在操作超时后的处理逻辑。在这里，打印超时信息。

回退策略

回退（降级）策略用于在操作失败时提供降级处理逻辑。回退策略在捕获到指定的异常时，不会让程序直接崩溃，而是执行一个定义好的备用操作，同时记录失败的原因。以下是一个简单的降级示例：

C#
using Polly;
using System;

class Program
{
    static void Main()
    {
        var fallbackPolicy = Policy
            .Handle<Exception>()
            .Fallback(() => {
                Console.WriteLine("Fallback action executed.");
            }, 
            (exception) => {
                Console.WriteLine($"Fallback due to: {exception.Message}");
            });

        fallbackPolicy.Execute(() => SimulateError());
    }

    static void SimulateError()
    {
        Console.WriteLine("Simulating error...");
        throw new InvalidOperationException("Simulated exception.");
    }
}

• Policy.Handle<Exception>()：指定要捕获的异常类型。在这里是所有的 Exception 类型。
• .Fallback(...)：定义回退策略。当捕获到指定异常时，会执行回退操作。
  • 第一个参数：回退操作，即当捕获到异常时执行的备用代码。在这里，打印 "Fallback action executed."。
  • 第二个参数：记录回退原因的操作，即捕获到异常时执行的代码。在这里，打印捕获到的异常的消息。

缓存策略

Polly 也支持缓存，可以用来缓存操作结果从而减少重复操作。以下是一个简单的缓存示例：

C#
using Polly;
using Polly.Caching;
using Polly.Caching.Memory;
using System;

class Program
{
    static void Main()
    {
        var memoryCacheProvider = new MemoryCacheProvider(new Microsoft.Extensions.Caching.Memory.MemoryCache(new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions()));

        var cachePolicy = Policy
            .Cache(memoryCacheProvider, TimeSpan.FromMinutes(1));

        int value = cachePolicy.Execute(() => SimulateExpensiveOperation());
        Console.WriteLine($"Operation result: {value}");

        // Running again to confirm the result is retrieved from cache
        value = cachePolicy.Execute(() => SimulateExpensiveOperation());
        Console.WriteLine($"Operation result (from cache): {value}");
    }

    static int SimulateExpensiveOperation()
    {
        Console.WriteLine("Performing expensive operation...");
        return 42;
    }
}

通过以上示例，我们了解了如何在 C# 项目中使用 Polly 实现各种弹性与瞬时故障处理策略。这些策略在处理分布式系统中的不稳定性和不可预测性时非常有用，能够显著提升应用程序的健壮性和可用性。

总结

1. 重试 (Retry)：处理临时性故障。
2. 断路器 (Circuit Breaker)：防止连续失败造成系统过载。
3. 超时 (Timeout)：限制长时间运行的操作以释放资源。
4. 回退 (Fallback)：提供备用方案或默认值应对无法恢复的错误。
5. 缓存 (Cache)：提高性能与响应速度，减小外部依赖。
6. 熔断 (Bulkhead Isolation)：限制并发请求保护系统资源。