.NetCore中结合ExceptionLess的处理对Polly再次封装

  /// <summary>
    /// Polly封装  liyouming
    /// </summary>

    public class PollyServicesFactory
    {

        private IELLog eLLog;
        public PollyServicesFactory(IELLog ellog)
        {
            eLLog = ellog;
        }

        #region 重试
        /// <summary>
        /// 组合使用Warp
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="num"></param>
        /// <returns></returns>
        public ISyncPolicy RetryWarp<TException>(int num) where TException : Exception
        {
            var policy = Policy
             .Handle<TException>()
             .Retry(num, (ex, count) =>
             {
                 eLLog.AddSource($"[Polly]")
                 .AddMessage($"执行失败!重试次数 {count}\r\n异常来自 {ex.GetType().Name}")
                 .AddTag("PollyRetry")
                 .AddSubmitWarn();
             });
            return policy;
        }
        public IAsyncPolicy RetryWarpAsync<TException>(int num) where TException : Exception
        {
            var policy = Policy
             .Handle<TException>()
             .RetryAsync(num, (ex, count) =>
             {
                 eLLog.AddSource($"[Polly]")
                 .AddMessage($"执行失败!重试次数 {count}\r\n异常来自 {ex.GetType().Name}")
                 .AddTag("PollyRetry")

                 .AddSubmitWarn();
             });
            return policy;
        }
        /// <summary>
        /// 服务重试 及重试次数
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="num"></param>
        public void PollyRetry<TException>(Action action, int num) where TException : Exception
        {
            var policy = Policy
              .Handle<TException>()
              .Retry(num, (ex, count) =>
              {
                  eLLog.AddSource($"[Polly]{action.Method.Name}")
                  .AddMessage($"执行失败!重试次数 {count}\r\n异常来自 {ex.GetType().Name}")
                  .AddTag("PollyRetry")
                  .AddTag(action.Method.Name)
                  .AddSubmitWarn();
              });

            policy.Execute(action);
        }

        public TResult PollyResultRetry<TException, TResult>(Func<TResult> action, int num) where TException : Exception
        {
            var policy = Policy
              .Handle<TException>()
              .Retry(num, (ex, count) =>
              {
                  eLLog.AddSource($"[Polly]{action.Method.Name}")
                  .AddMessage($"执行失败!重试次数 {count}\r\n异常来自 {ex.GetType().Name}")
                  .AddTag("PollyRetry")
                  .AddTag(action.Method.Name)
                  .AddSubmitWarn();
              });

            return policy.Execute(action);
        }

        /// <summary>
        /// 服务重试 及重试次数
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="num"></param>
        public async Task PollyRetryAsync<TException>(Func<Task> action, int num) where TException : Exception
        {
            var policy = Policy
              .Handle<TException>()
              .RetryAsync(num, (ex, count) =>
              {
                  eLLog.AddSource($"[Polly]{action.Method.Name}")
                  .AddMessage($"执行失败!重试次数 {count}\r\n异常来自 {ex.GetType().Name}")
                  .AddTag("PollyRetryAsync")
                  .AddTag(action.Method.Name)
                  .AddSubmitWarn();
              });

            await policy.ExecuteAsync(action);
        }

        public async Task<TResult> PollyResultRetryAsync<TException, TResult>(Func<Task<TResult>> action, int num) where TException : Exception
        {
            var policy = Policy
              .Handle<TException>()
              .RetryAsync(num, (ex, count) =>
              {
                  eLLog.AddSource($"[Polly]{action.Method.Name}")
                  .AddMessage($"执行失败!重试次数 {count}\r\n异常来自 {ex.GetType().Name}")
                  .AddTag("PollyRetryAsync")
                  .AddTag(action.Method.Name)
                  .AddSubmitWarn();
              });

            return await policy.ExecuteAsync(action);
        }

        #endregion

        #region 重试 TimeSpan
        /// <summary>
        /// 重试 Warp
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="timeSpans"></param>
        /// <returns></returns>
        public ISyncPolicy WaitAndRetryWarp<TException>(params TimeSpan[] timeSpans) where TException : Exception
        {
            var policy = Policy
            .Handle<TException>()
            .WaitAndRetry(timeSpans, (e, tiempo, intento, contexto) =>
            {
                eLLog.AddSource($"[Polly]")
                 .AddMessage($"异常: {intento:00} (调用秒数: {tiempo.Seconds} 秒)\t执行时间: {DateTime.Now}")
                 .AddTag("WaitAndRetry")
                 .AddSubmitWarn();

            });
            return policy;
        }

        public IAsyncPolicy WaitAndRetryWarpAsync<TException>(params TimeSpan[] timeSpans) where TException : Exception
        {
            var policy = Policy
            .Handle<TException>()
            .WaitAndRetryAsync(timeSpans, (e, tiempo, intento, contexto) =>
            {
                eLLog.AddSource($"[Polly]")
                 .AddMessage($"异常: {intento:00} (调用秒数: {tiempo.Seconds} 秒)\t执行时间: {DateTime.Now}")
                 .AddTag("WaitAndRetry")

                 .AddSubmitWarn();

            });
            return policy;
        }

        /// <summary>
        /// 按需要的周期重试
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="timeSpans"></param>
        /// <returns></returns>
        public void PollyWaitAndRetry<TException>(Action action, params TimeSpan[] timeSpans) where TException : Exception
        {
            var policy = Policy
            .Handle<TException>()
            .WaitAndRetry(timeSpans, (e, tiempo, intento, contexto) =>
            {

                eLLog.AddSource($"[Polly]{action.Method.Name}")
                 .AddMessage($"异常: {intento:00} (调用秒数: {tiempo.Seconds} 秒)\t执行时间: {DateTime.Now}")
                 .AddTag("WaitAndRetry")
                 .AddTag(action.Method.Name)
                 .AddSubmitWarn();

            });
            policy.Execute(action);
        }

        public TResult PollyResultWaitAndRetry<TException, TResult>(Func<TResult> action, params TimeSpan[] timeSpans) where TException : Exception
        {
            var policy = Policy
            .Handle<TException>()
            .WaitAndRetry(timeSpans, (e, tiempo, intento, contexto) =>
            {

                eLLog.AddSource($"[Polly]{action.Method.Name}")
                 .AddMessage($"异常: {intento:00} (调用秒数: {tiempo.Seconds} 秒)\t执行时间: {DateTime.Now}")
                 .AddTag("WaitAndRetry")
                 .AddTag(action.Method.Name)
                 .AddSubmitWarn();

            });
            return policy.Execute(action);
        }

        /// <summary>
        /// 按需要的周期重试
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="timeSpans"></param>
        /// <returns></returns>
        public async Task PollyWaitAndRetryAsync<TException>(Func<Task> action, params TimeSpan[] timeSpans) where TException : Exception
        {
            var policy = Policy
            .Handle<TException>()
            .WaitAndRetryAsync(timeSpans, (e, tiempo, intento, contexto) =>
            {

                eLLog.AddSource($"[Polly]{action.Method.Name}")
                 .AddMessage($"异常: {intento:00} (调用秒数: {tiempo.Seconds} 秒)\t执行时间: {DateTime.Now}")
                 .AddTag("WaitAndRetryAsync")
                 .AddTag(action.Method.Name)
                 .AddSubmitWarn();

            });
            await policy.ExecuteAsync(action);
        }

        public async Task<TResult> PollyResultWaitAndRetryAsync<TException, TResult>(Func<Task<TResult>> action, params TimeSpan[] timeSpans) where TException : Exception
        {
            var policy = Policy
            .Handle<TException>()
            .WaitAndRetryAsync(timeSpans, (e, tiempo, intento, contexto) =>
            {

                eLLog.AddSource($"[Polly]{action.Method.Name}")
                 .AddMessage($"异常:{e.Message} {intento:00} (调用秒数: {tiempo.Seconds} 秒)\t执行时间: {DateTime.Now}")
                 .AddTag("WaitAndRetryAsync")
                 .AddTag(action.Method.Name)
                 .AddSubmitWarn();

            });
            return await policy.ExecuteAsync(action);
        }

        #endregion

        #region 指定特定返回值
        public ISyncPolicy<OperatorResult> FallBackWarp<TException>() where TException : Exception
        {
            var pollyfallback = Policy<OperatorResult>.Handle<TException>()
                  .Fallback(new OperatorResult
                  {
                      Result = ResultType.Fail,
                      Message = "执行失败"
                  });

            return pollyfallback;

        }

        public IAsyncPolicy<OperatorResult> FallBackWarpAsync<TException>() where TException : Exception
        {
            var pollyfallback = Policy<OperatorResult>.Handle<TException>()
                  .FallbackAsync(new OperatorResult
                  {
                      Result = ResultType.Fail,
                      Message = "执行失败"
                  });

            return pollyfallback;

        }
        /// <summary>
        /// 监控特定错误指定返回值
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <returns></returns>
        public OperatorResult PollyFallBack<TException>(Func<OperatorResult> action) where TException : Exception
        {
            var pollyfallback = Policy<OperatorResult>.Handle<TException>()
                  .Fallback(() =>
                  {

                      return new OperatorResult
                      {
                          Result = ResultType.Fail,
                          Message = action.Method.Name + "执行失败"
                      };
                  });

            return pollyfallback.Execute(action);

        }

        /// <summary>
        /// 监控特定错误指定返回值
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <returns></returns>
        public async Task<OperatorResult> PollyFallBackAsync<TException>(Func<Task<OperatorResult>> action) where TException : Exception
        {
            var pollyfallback = Policy<OperatorResult>.Handle<TException>()
                  .FallbackAsync(new OperatorResult
                  {
                      Result = ResultType.Fail,
                      Message = action.Method.Name + "执行失败"
                  }
                  );

            return await pollyfallback.ExecuteAsync(action);

        }
        #endregion

        #region 熔断

        public ISyncPolicy CircuitBreakerWarp<TException>(int num, TimeSpan timeSpan) where TException : Exception
        {
            var policy = Policy
          .Handle<TException>()
          .CircuitBreaker(num, timeSpan);
            return policy;
        }

        public IAsyncPolicy CircuitBreakerWarpAsync<TException>(int num, TimeSpan timeSpan) where TException : Exception
        {
            var policy = Policy
           .Handle<TException>()
           .CircuitBreakerAsync(num, timeSpan);
            return policy;
        }
        /// <summary>
        /// 熔断 仓壁隔离
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="num"></param>
        /// <param name="timeSpan"></param>
        public void PollyCircuitBreaker<TException>(Action action, int num, TimeSpan timeSpan) where TException : Exception
        {
            var policy = Policy
                   .Handle<TException>()
                   .CircuitBreaker(num, timeSpan);
            while (true)
            {
                try
                {
                    policy.Execute(action);
                }
                catch (Exception ex)
                {
                    eLLog.AddSource($"[Polly]{action.Method.Name}")
                      .AddMessage($"异常: {ex.Message} \t执行时间: {DateTime.Now}")
                      .AddTag("PollyCircuitBreaker")
                      .AddTag(action.Method.Name)
                      .AddSubmitWarn();
                }
                Thread.Sleep();
            }

        }
        public Task<TResult> PollyResultCircuitBreaker<TException, TResult>(Func<Task<TResult>> action, int num, TimeSpan timeSpan) where TException : Exception
        {
            var policy = Policy
                   .Handle<TException>()
                   .CircuitBreaker(num, timeSpan);
            while (true)
            {
                try
                {
                 return   policy.Execute(action);
                }
                catch (Exception ex)
                {
                    eLLog.AddSource($"[Polly]{action.Method.Name}")
                      .AddMessage($"异常: {ex.Message} \t执行时间: {DateTime.Now}")
                      .AddTag("PollyCircuitBreaker")
                      .AddTag(action.Method.Name)
                      .AddSubmitWarn();
                }
                Thread.Sleep();
            }

        }
        /// <summary>
        /// 熔断 仓壁隔离
        /// </summary>
        /// <typeparam name="TException"></typeparam>
        /// <param name="action"></param>
        /// <param name="num"></param>
        /// <param name="timeSpan"></param>
        public async Task PollyCircuitBreakerAsync<TException>(Func<Task> action, int num, TimeSpan timeSpan) where TException : Exception
        {
            var policy = Policy
             .Handle<TException>()
             .CircuitBreakerAsync(num, timeSpan);

            while (true)
            {
                try
                {
                    await policy.ExecuteAsync(action);
                }
                catch (Exception ex)
                {
                    eLLog.AddSource($"[Polly]{action.Method.Name}")
                      .AddMessage($"异常: {ex.Message} \t执行时间: {DateTime.Now}")
                      .AddTag("PollyCircuitBreaker")
                      .AddTag(action.Method.Name)
                      .AddSubmitWarn();
                }
                Thread.Sleep();
            }

        }

        public async Task<TResult> PollyResultCircuitBreakerAsync<TException, TResult>(Func<Task<TResult>> action, int num, TimeSpan timeSpan) where TException : Exception
        {
            var policy = Policy
              .Handle<TException>()
              .CircuitBreakerAsync(num, timeSpan);

            while (true)
            {
                try
                {
                 return   await policy.ExecuteAsync(action);
                }
                catch (Exception ex)
                {
                    eLLog.AddSource($"[Polly]{action.Method.Name}")
                      .AddMessage($"异常: {ex.Message} \t执行时间: {DateTime.Now}")
                      .AddTag("PollyCircuitBreaker")
                      .AddTag(action.Method.Name)
                      .AddSubmitWarn();
                }
                Thread.Sleep();
            }
        }

        #endregion

        #region 组合各种场景
        public void PollyWarp(Action action, params ISyncPolicy[] syncPolicies)
        {
            var mixedPolicy = Policy.Wrap(syncPolicies);

            mixedPolicy.Execute(action);
        }
        public async Task PollyWarpAsync(Func<Task> action, params IAsyncPolicy[] syncPolicies)
        {
            var mixedPolicy = Policy.WrapAsync(syncPolicies);
            await mixedPolicy.ExecuteAsync(action);
        }
        #endregion

    }

感觉封装了下也没什么太大的卵用~ 浪费了时间，但是还是贴出来