.Net Core Polly 重试策略 超时策略 缓存策略…（Polly Demo精编）

Polly这个东西比较早的时候有去了解，没有实际应用也快忘得差不多了。

近期有个任务是把项目中的Hangfire依赖移除。项目中使用Hangfire执行一个定期任务，周期是一秒。

原本项目已经用到了Hangfire,选用它做定期Job是“顺其自然+想当然”的，但它因为在仪表盘产生大量的log，影响其他项目的Debug，所以领导决定弃用它。

替代方案考虑了Thread、Thread.Timer、Polly、BackgroundService、IHostService。

个人选择创建一个派生自BackgroundService的Monitor类，后由于领导对性能高要求，最后又改为了Timer实现。

在最终实现方案确定前，又想到了Polly，所以就再次温习了一下。

看网上的讲解零零散散的，Demo也多比较潦草（且多是复制转载），于是决定自己整理一套更容易让大家看懂的Demo。

温馨提示：

在深究某个Demo的具体代码前，建议先理解一下这个Demo模拟的具体场景。

之所以整理这些Demo是因为看了很多文章，都是单纯的在贴代码，有些人代码都看懂了，但是根本不知道怎么用。

所以我尽可能地用有限的代码和注释模拟一个较为接近真实的应用场景。这有助于更好地立即Polly的使用场景和功能细节。

DemoBase

因为创建了一个独立的完整项目，所以所有Demo均继承自DemoBase类，提供公用的一些方法。

如果希望运行这些Demo，注意添加此类并使用下面的Program类。

using System;

namespace Demo.Core
{
    public abstract class DemoBase
    {
        public abstract string DemoName { get; }

        public void PrintText(string message, ConsoleColor consoleColor)
        {
            lock (this)
            {
                var oriColor = Console.ForegroundColor;
                Console.ForegroundColor = consoleColor;
                Console.WriteLine(message);
                Console.ForegroundColor = oriColor;
            }
        }

        public void Init()
        {
            PrintText($"------------{DemoName}------------", ConsoleColor.Cyan);
        }

        public void PrintInfo(string message)
        {
            Console.WriteLine(message);
        }

        public void PrintError(string message)
        {
            PrintText(message, ConsoleColor.Red);
        }

        public void PrintSuccess(string message)
        {
            PrintText(message, ConsoleColor.Green);
        }

        public void PrintTimeNow()
        {
            Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
        }

        public void PrintLog(string message, ConsoleColor consoleColor = ConsoleColor.DarkGray)
        {
            PrintText($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}	{message}", consoleColor);
        }

        public void PrintSuccessLog(string message)
        {
            PrintLog(message, ConsoleColor.DarkGreen);
        }

        public void PrintErrorLog(string message)
        {
            PrintLog(message, ConsoleColor.DarkRed);
        }

        public abstract void RunDemo();
    }
}

using Demo.Core;
using System;
using System.Collections.Generic;
using System.Linq;

namespace PollyDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            var demos = new List<DemoBase>();
            demos.Add(new Retry());
            demos.Add(new CircuitBreaker());
            demos.Add(new AdvancedCircuitBreaker());
            demos.Add(new Timeout());
            demos.Add(new Fallback());
            demos.Add(new Wrap());
            demos.Add(new Cache());
            demos.Add(new BulkheadIsolation());

            bool continueDemo = true;
            do
            {
                Console.WriteLine("-------请选择执行Demo-------");
                int index = 0;
                var demoList = demos.Select(x => $"{++index}:{ x.GetType().Name}
").ToList();
                demoList.Add("c:清空历史
");
                demoList.Add("q:退出
");

                Console.WriteLine(string.Concat(demoList));
                var input = Console.ReadLine();
                if(input == "q")
                {
                    break;
                }
                if(input == "c")
                {
                    Console.Clear();
                    continue;
                }
                if (int.TryParse(input, out int value))
                {
                    if (value <= 0)
                    {
                        Console.WriteLine("输入数字超出范围");
                        continue;
                    }
                    if (value > demos.Count)
                    {
                        Console.WriteLine("输入数字超出范围");
                        continue;
                    }
                    demos[value - 1].RunDemo();
                    Console.WriteLine("-------执行Demo完毕-------");
                }
                else
                {
                    Console.WriteLine("请输入有效编号");
                }
            }
            while (continueDemo);
        }
    }
}

Retry

public class Retry: DemoBase
    {
        public override string DemoName => "Polly-Retry Demo";

        /// <summary>
        /// 老板开出工资
        /// </summary>
        int SalaryFromBoss = 10_000;

        public override void RunDemo()
        {
            base.Init();
            try
            {
                int retryTimes = 5;
                
                var retryTwoTimesPolicy = Policy
                    .Handle<SalaryException>()      //支持的第1种异常类型
                    .Or<TimeException>()            //支持的第2种异常类型
                    .Or<Exception>(ex => ex.Message == "攻城狮有点犹豫")   //注意这个限定 这个根据业务场景 有很大灵活运用空间
                    //.OrInner<Exception>()         //不再赘述
                    //.RetryForever();<Exception>() //不再赘述
                    //.WaitAndRetry(new[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(4) }
                    .Retry(retryTimes, (ex, onRetry) =>
                    {                        
                        PrintInfo($"攻城狮说:{ex.Message}");
                        PrintInfo($"第{onRetry}次谈心（薪）失败 老板得重新谈
");
                        老板调薪();
                    });
                retryTwoTimesPolicy.Execute(() =>
                {
                    与老板谈心();
                    PrintSuccess("谈心成功");
                });
            }
            catch (Exception e)
            {
                PrintError($"超出老板的预料：{e.Message}");
            }
        }

        private void 老板调薪()
        {
            SalaryFromBoss = SalaryFromBoss + 10_000;
            PrintInfo($"与老板谈心 给出薪资{SalaryFromBoss}");
        }

        private void 与老板谈心()
        {

            if (SalaryFromBoss < 20_000)
            {
                throw new TimeException($"天天都在加班，世界那么大，我想去走走。");               
            }
            if (SalaryFromBoss < 30_000)
            {
                throw new SalaryException(SalaryFromBoss, $"薪资太少，您没别的事，我回去写Bug了！");
            }
            if (SalaryFromBoss < 40_000)
            {
                if (DateTime.Now.Second % 2 == 0)
                    throw new Exception("攻城狮有点犹豫");
                else
                    throw new Exception("攻城狮没接电话 这下没法谈了");//这个指定类型和场景之外的异常 不会出发重试机制
            }
            PrintInfo($"攻城狮说：我这就回去赶进度~");
        }
    }

    class SalaryException : Exception
    {
        int Salary { get; set; }

        public SalaryException(int salary, string message) : base(message)
        {
            Salary = salary;
        }
    }

    class TimeException : Exception
    {
        public TimeException(string message) : base(message)
        {
            
        }
    }

Timeout

public class Timeout : DemoBase
    {
        public override string DemoName => "Polly-Timeout Demo";

        public override void RunDemo()
        {
            base.Init();

            int runTimes = 10;
            int timeout = 2;

            var policy = Policy.Timeout(timeout, Polly.Timeout.TimeoutStrategy.Pessimistic);

            for (int i = 1; i <= runTimes; i++)
            {
                try
                {
                    PrintInfo($"第{i}次执行");
                    policy.Execute(RequestFromWeb);
                }
                catch (Exception e)
                {
                    PrintError($"异常：{e.GetType().Name},{e.Message}");
                }
            }
        }

        private void RequestFromWeb()
        {
            if (new Random().Next(10) < 5)
            {
                Thread.Sleep(3_000);
            }
            else
            {
                PrintSuccessLog("网络请求响应完毕");
            }
        }
    }

Wrap

public class Wrap : DemoBase
    {
        public override string DemoName => "Polly-Wrap Demo";

        public override void RunDemo()
        {
            //https://github.com/beckjin/PollySamples/blob/master/App/Polly/Wrap.cs
            base.Init();
            int timeout = 2;
            ISyncPolicy policyException = Policy.Handle<TimeoutRejectedException>()
                    .Fallback(() =>
                    {
                        PrintErrorLog("执行降级该执行的操作");
                    });
            ISyncPolicy policyTimeout = Policy.Timeout(timeout, TimeoutStrategy.Pessimistic);
            //ISyncPolicy mainPolicy = Policy.Wrap(policyTimeout, policyException);
            ISyncPolicy mainPolicy = policyTimeout.Wrap( policyException);
            try
            {
                for (int i = 0; i < 5; i++)
                {
                    mainPolicy.Execute(RequestFromWeb);
                }
            }
            catch (Exception e)
            {
                PrintError($"异常：{e.GetType().Name},{e.Message}");
            }
        }

        private void RequestFromWeb()
        {            
            if (new Random().Next(10) < 5)
            {
                PrintLog("开始请求大数据包");
                Thread.Sleep(3000);
                PrintSuccessLog("请求大数据包成功");
            }
            else
            {
                PrintLog("开始请求小数据包");
                Thread.Sleep(100);
                PrintSuccessLog("请求小数据包成功");
            }
        }
    }

public class Fallback : DemoBase
    {
        public override string DemoName => "Polly-Fallback Demo";

        /// <summary>
        /// 全局动态调整时长
        /// </summary>
        private int _timeout = 1;
        public override void RunDemo()
        {
            base.Init();

            var mainPolicy = Policy.Handle<Exception>()
                    .Fallback(() =>
                    {
                        _timeout++;
                        PrintErrorLog($"数据量太大 调整超时时间：{_timeout} 秒");
                    });
            try
            {
                for (int i = 0; i < 10; i++)
                {
                    mainPolicy.Execute(RequestFromWeb);
                }
            }
            catch (Exception e)
            {
                PrintError($"异常：{e.GetType().Name},{e.Message}");
            }
        }

        private void RequestFromWeb()
        {
            if (_timeout < 5)
            {
                PrintLog("开始请求数据包");
                Thread.Sleep(_timeout * 1000);
                throw new WebException("请求超时");
            }
            else
            {
                PrintLog("开始请求数据包");
                Thread.Sleep(_timeout * 1000);
                PrintSuccessLog("请求数据包成功");
                _timeout = 3;//模拟网络状态变化
            }
        }
    }

CircuitBreaker

public class CircuitBreaker : DemoBase
    {
        public override string DemoName => "Polly-Basic CircuitBreaker Demo";

        public override void RunDemo()
        {
            base.Init();

            int runTimes = 8;
            int exceptionTimes = runTimes - 3;
            int durationOfBreak = 5;

            var policy = Policy
                .Handle<Exception>()
                .CircuitBreaker(exceptionTimes, TimeSpan.FromSeconds(durationOfBreak));

            for (int i = 1; i <= runTimes; i++)
            {
                try
                {
                    PrintInfo($"第{i}次执行");
                    policy.Execute(RequestFromWeb);                    
                }
                catch (BrokenCircuitException e)
                {
                    PrintError($"熔断触发{nameof(BrokenCircuitException)}异常：{e.Message}");
                }
                catch (Exception e)
                {
                    PrintError($"异常：{e.GetType().Name},{e.Message}");
                }
            }
        }

        private void RequestFromWeb()
        {
            throw new Exception("调用方法抛出异常");
        }

    }

Bulkhead Isolation

public class BulkheadIsolation : DemoBase
    {
        public override string DemoName => "Polly-Bulkhead Isolation Demo";
        int resourceId = 0;

        public override void RunDemo()
        {
            base.Init();
            resourceId = 0;
            //制定策略最大的并发数为5
            Policy policyExecutes = Policy.Bulkhead(5);
            for (int i = 0; i < 50; i++)
            {
                Task.Factory.StartNew(() =>
                {
                    try
                    {
                        policyExecutes.Execute(() =>
                        {
                            RequestFromWeb();
                        });
                    }
                    catch (Exception ex)
                    {
                        PrintErrorLog(ex.Message);
                        throw;
                    }
                });
            }
        }

        
        private void RequestFromWeb()
        {
            resourceId++;//模拟异常场景
            if (resourceId % 3 == 0)
            {
                throw new Exception($"请求数据包{resourceId}失败 请求过于频繁（报异常 但程序没崩溃哟）");
            }
            else
            {
                PrintSuccessLog($"请求数据包{resourceId}成功");
            }
        }
    }

AdvancedCircuitBreaker

public class AdvancedCircuitBreaker : DemoBase
    {
        public override string DemoName => "Polly-Advanced CircuitBreaker Demo";

        public override void RunDemo()
        {
            base.Init();

            int runTimes = 50;
            int minimumThroughput = 5;
            int durationOfBreak = 5;
            int samplingDuration = 5;


            var policy = Policy
                .Handle<Exception>()
                .AdvancedCircuitBreaker(
                failureThreshold: 0.5,                       //失败率达到50%才熔断
                minimumThroughput: minimumThroughput,        //最多调用多少次
                samplingDuration: TimeSpan.FromSeconds(samplingDuration),   //评估故障率的时间间隔的持续时间
                durationOfBreak: TimeSpan.FromSeconds(durationOfBreak),    //熔断时间
                onBreak: (ex, breakDelay) =>                 //熔断器打开时触发事件
                {
                    PrintErrorLog($"进入熔断状态 熔断时长：{breakDelay} 错误信息：{ex.Message}");
                },
                onHalfOpen: () =>                           //熔断器进入半打开状态触发事件
                {
                    PrintSuccessLog($"进入HalfOpen状态");
                },
                onReset: () =>                              //熔断器关闭状态触发事件
                {
                    PrintSuccessLog("熔断器关闭");
                }
                );

            for (int i = 1; i <= runTimes; i++)
            {
                try
                {
                    policy.Execute(RequestFromWeb);                    
                }
                catch (BrokenCircuitException e)
                {
                    PrintLog($"熔断触发{nameof(BrokenCircuitException)}异常");
                }
                catch (Exception e)
                {
                    PrintLog($"异常：{e.GetType().Name},{e.Message}");
                }
                finally
                {
                    Thread.Sleep(500);
                }
            }
        }

        private void RequestFromWeb()
        {
            if (new Random().Next(10) < 5)
            {
                throw new Exception("调用方法内部异常");
            }
            else
            {
                PrintSuccessLog("内部方法执行成功");
            }
        }

    }

Cache

public class Cache : DemoBase
    {
        public override string DemoName => "Polly-Cache Demo";

        public override void RunDemo()
        {
            base.Init();

            var memoryCache = new MemoryCache(new MemoryCacheOptions());
            ISyncCacheProvider memoryCacheProvider = new MemoryCacheProvider(memoryCache);

            CachePolicy cache = Policy.Cache(memoryCacheProvider, ttl: TimeSpan.FromSeconds(3));//此处可以传递更多细节配置 当前仅设置了缓存超时时长

            for (int i = 0; i < 5; i++)
            {
                string orderId = "12345678";
                Context policyExecutionContext = new Context("GetOrder-By-Id-");
                policyExecutionContext["orderId"] = orderId;
                var result = cache.Execute(context => GetOrderInfoById(orderId), policyExecutionContext);
                PrintInfo($"订单详情：{result}");
                Thread.Sleep(i * 1000);
            }
        }

        private string GetOrderInfoById(string orderId)
        {
            PrintInfo("从数据获取订单信息");
            return $"订单号：{orderId} 订单金额：￥{124.5}";
        }
    }

 努力工作 认真生活 持续学习 以勤补拙