/// <summary>
/// 悲观超时
/// </summary>
static void PessimisticTimeOutTest()
{
CancellationTokenSource userCancellationSource = new CancellationTokenSource();
ISyncPolicy fallback = Policy.Handle <Polly.Timeout.TimeoutRejectedException>()
.Or <ArgumentException>()
.Fallback(() =>
{
Console.WriteLine("Error occured,runing fallback");
},
(ex) => { Console.WriteLine($"Fallback exception:{ex.GetType().ToString()},Message:{ex.Message}"); });
ISyncPolicy policyTimeout = Policy.Timeout(3, Polly.Timeout.TimeoutStrategy.Pessimistic);
while (true)
{
var policyWrap = Policy.Wrap(fallback, policyTimeout);
// (wraps the policies around any executed delegate: fallback outermost ... bulkhead innermost)
policyWrap.Execute(() =>
{
Console.WriteLine("Job Start");
if (DateTime.Now.Second % 2 == 0)
{
Thread.Sleep(3000);
throw new ArgumentException("Hello Polly!");
}
});
Thread.Sleep(300);
}
}
public void Should_restore_PolicyKey_of_outer_policy_to_execution_context_as_move_outwards_through_PolicyWrap()
{
ISyncPolicy fallback = Policy
.Handle <Exception>()
.Fallback(_ => {}, onFallback: (_, context) =>
{
context.PolicyWrapKey.Should().Be("PolicyWrap");
context.PolicyKey.Should().Be("FallbackPolicy");
})
.WithPolicyKey("FallbackPolicy");
ISyncPolicy retry = Policy
.Handle <Exception>()
.Retry(1, onRetry: (result, retryCount, context) =>
{
context.PolicyWrapKey.Should().Be("PolicyWrap");
context.PolicyKey.Should().Be("RetryPolicy");
})
.WithPolicyKey("RetryPolicy");
ISyncPolicy policyWrap = Policy.Wrap(fallback, retry)
.WithPolicyKey("PolicyWrap");
policyWrap.Execute(() => throw new Exception());
}
internal static void Implementation(
Action <Context, CancellationToken> action,
Context context,
CancellationToken cancellationToken,
ISyncPolicy outerPolicy,
ISyncPolicy innerPolicy)
=> outerPolicy.Execute((ctx, ct) => innerPolicy.Execute(action, ctx, ct), context, cancellationToken);
private static void Demo2()
{
try
{
//ISyncPolicy policy = Policy.Handle<Exception>().WaitAndRetry(new TimeSpan[] { TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(2000) });
//ISyncPolicy policy = Policy.Handle<Exception>().RetryForever( );
ISyncPolicy policy = Policy.Handle <Exception>().Retry();
//RetryForever();
//Policy.Handle<Exception>().Retry
//Policy.Handle<Exception>().RetryForever
//Policy.Handle<Exception>().Fallback
//Policy.Handle<Exception>().CircuitBreaker
//Policy.Handle<Exception>().WaitAndRetry
policy.Execute(() =>
{
Console.WriteLine("开始任务");
//if (Environment.TickCount % 2 == 0)
if (DateTime.Now.Second % 5 != 0)
{
throw new Exception("出错");
}
Console.WriteLine("完成任务");
});
}
catch (Exception ex)
{
Console.WriteLine("未处理异常" + ex);
}
}
public PolicyFactory()
{
PollyPolicy pollyPolicy = GetPollyPolicy();
this._asyncPolicy = GetAsyncPolicyConfigs(pollyPolicy.Policies);
this._syncPolicy = GetSyncPolicyConfigs(pollyPolicy.Policies);
}
public static void Wrap()
{
try
{
ISyncPolicy policyException = Policy.Handle <TimeoutRejectedException>() //只针对超时异常
.Fallback(() =>
{
Console.WriteLine("fallback");
});
ISyncPolicy policytimeout = Policy.Timeout(2, Polly.Timeout.TimeoutStrategy.Pessimistic);//乐观和悲观
//ISyncPolicy policy3 = policyException.Wrap(policytimeout);//
ISyncPolicy policy3 = Policy.Wrap(policyException, policytimeout);
policy3.Execute(() =>
{
Console.WriteLine("开始任务");
Thread.Sleep(5000);
// throw new Exception();
Console.WriteLine("完成任务");
});
}
catch (Exception ex)
{
Console.WriteLine("未处理异常" + ex.GetType() + ":" + ex.Message);
}
}
public static void CircuitBreaker()
{
int i = 0;
ISyncPolicy policy = Policy
.Handle <Exception>()
.CircuitBreaker(6, TimeSpan.FromSeconds(5));//连续出错6次之后熔断5秒(不会再去尝试执行业务代码）。
while (true)
{
Console.WriteLine("开始Execute");
try
{
policy.Execute(() =>
{
i++;
Console.WriteLine("开始任务");
if (i < 8)
{
throw new Exception("出错");
}
Console.WriteLine("完成任务");
});
}
catch (Exception ex)
{
Console.WriteLine("execute出错" + ex.GetType() + ":" + ex.Message);
}
Thread.Sleep(1000);
}
}
private static void Main(string[] args)
{
var unstableService = new MrUnstable();
ISyncPolicy redo1 = Policy.Handle <ApplicationException>()
.Retry(1,
(exception, count) =>
{
Console.WriteLine($"ApplicationException, exception:{exception.Message}, count:{count}");
});
ISyncPolicy benFallback = Policy.Handle <ApplicationException>()
.Fallback(() =>
{
Console.WriteLine("Execute Fallback action");
}, ex =>
{
Console.WriteLine($"on fallback, exception message:{ex.Message.ToString()}");
});
benFallback.Execute(() =>
{
redo1.Execute(() =>
{
unstableService.SpecificException(new ApplicationException());
});
});
Console.Read();
}
public void Should_restore_PolicyKey_of_outer_policy_to_execution_context_as_move_outwards_through_PolicyWrap()
{
ISyncPolicy <ResultPrimitive> fallback = Policy <ResultPrimitive>
.Handle <Exception>()
.Fallback <ResultPrimitive>(ResultPrimitive.Undefined, onFallback: (_, context) =>
{
context.PolicyWrapKey.Should().Be("PolicyWrap");
context.PolicyKey.Should().Be("FallbackPolicy");
})
.WithPolicyKey("FallbackPolicy");
ISyncPolicy <ResultPrimitive> retry = Policy <ResultPrimitive>
.Handle <Exception>()
.Retry(1, onRetry: (_, _, context) =>
{
context.PolicyWrapKey.Should().Be("PolicyWrap");
context.PolicyKey.Should().Be("RetryPolicy");
})
.WithPolicyKey("RetryPolicy");
Policy <ResultPrimitive> policyWrap = Policy.Wrap(fallback, retry)
.WithPolicyKey("PolicyWrap");
policyWrap.Execute(() => throw new Exception());
}
public static void RetryDowngrade()
{
try
{
//降级处理程序
ISyncPolicy policy = Policy.Handle <Exception>()
.Fallback(() =>
{
Console.WriteLine("降级成功");
});
//配置重试次数
ISyncPolicy policy2 = Policy.Handle <Exception>().Retry(3, (exception, retryCount, context) =>
{
Console.WriteLine(retryCount);
});
//合并
ISyncPolicy mainPolicy = Policy.Wrap(policy, policy2);
mainPolicy.Execute(() =>
{
Console.WriteLine("任务开始");
throw new Exception("出错了");
Console.WriteLine("任务结束");
});
}
catch (Exception ex)
{
Console.WriteLine("异常结果 : " + ex.Message);
}
}
public static void Fusing()
{
Action <Exception, TimeSpan> onBreak = (exception, timespan) =>
{
Console.WriteLine("1");
};
Action onReset = () =>
{
Console.WriteLine("2");
};
ISyncPolicy policy = Policy.Handle <Exception>().CircuitBreaker(3, TimeSpan.FromSeconds(20), onBreak, onReset);
while (true)
{
try
{
policy.Execute(() =>
{
Console.WriteLine("任务开始");
throw new Exception("出错了");
Console.WriteLine("任务结束");
});
}
catch (Exception ex)
{
Console.WriteLine("---------------异常结果-------------- : " + ex.Message + "时间:" + DateTime.Now);
}
System.Threading.Thread.Sleep(5000);
}
}
public PollyQueryHandler(IQueryHandler <TQuery, TResult> handler, ISyncPolicy policy)
{
Condition.Requires(handler, nameof(handler)).IsNotNull();
Condition.Requires(policy, nameof(policy)).IsNotNull();
this.handler = handler;
this.policy = policy;
}
protected CrmDatastoreBase(
ILogger <CrmDatastoreBase <T> > logger,
ISyncPolicyFactory policy)
{
_logger = logger;
_policy = policy.Build(_logger);
}
public PollyCommandHandler(ICommandHandler <TCommand> handler, ISyncPolicy policy)
{
Condition.Requires(handler, nameof(handler)).IsNotNull();
Condition.Requires(policy, nameof(policy)).IsNotNull();
this.handler = handler;
this.policy = policy;
}
public static void Case1()
{
ISyncPolicy policy = Policy.Handle <ArgumentException>()
.Fallback(() =>
{
Console.WriteLine("Error occured");
});
policy.Execute(() =>
{
//try
//{
Console.WriteLine("Job Start");
throw new ArgumentException("sdada");
var ss = SumNum();
Console.WriteLine($"Result {ss}");
//}
//catch (AggregateException ex)
//{
// Console.WriteLine("我是错误的方法");
//}
//finally
//{
// Console.WriteLine("Job End");
//}
//throw new ArgumentException("Hello Polly!");
});
}
/// <summary>
/// 超时处理
/// 用途：请求网络接口，避免接口长期没有响应造成系统卡死。
/// </summary>
private static void Timeout()
{
ISyncPolicy policy = Policy.Handle <Exception>()
.Fallback(() =>
{
Console.WriteLine("执行出错");
}, ex =>
{
Console.WriteLine("详细异常对象" + ex);
});
policy = policy.Wrap(Policy.Timeout(2, TimeoutStrategy.Pessimistic));
policy.Execute(() =>
{
Console.WriteLine("开始任务");
Thread.Sleep(5000);
Console.WriteLine("完成任务");
});
// ISyncPolicy policy = Policy.Handle<TimeoutRejectedException>()
//.Retry(1);
// policy = policy.Wrap(Policy.Timeout(3, TimeoutStrategy.Pessimistic));
// policy.Execute(() =>
// {
// Console.WriteLine("开始任务");
// Thread.Sleep(5000);
// Console.WriteLine("完成任务");
// });
}
public SyncPolicyFactory(IOptions <PolicyOptions> policyOptions)
{
policyOptions = Guard.IsNotNull(policyOptions, "policyOptions");
var val = Policy.Handle((Func <SqlException, bool>)(ex => this.IsTransientSqlException(ex)))
.WaitAndRetry(policyOptions.Value.DbRetryCount,
attempt => TimeSpan.FromMilliseconds(policyOptions.Value.DbRetryBaseDelay * attempt));
var circuitBreakerSqlPolicy = Policy
.Handle((Func <SqlException, bool>)(ex => this.IsTransientSqlException(ex))).CircuitBreaker(
policyOptions.Value.DbCircuitBreakerErrorCount,
TimeSpan.FromMilliseconds(policyOptions.Value.DbCircuitBreakerDelay));
this.dbExecutionSyncPolicy = val.Execute(() => circuitBreakerSqlPolicy);
var val2 = Policy.Handle <Exception>().WaitAndRetry(policyOptions.Value.ApiRetryCount,
attempt => TimeSpan.FromMilliseconds(policyOptions.Value.ApiRetryBaseDelay * attempt));
var circuitBreakerApiPolicy = Policy.Handle <Exception>().CircuitBreaker(
policyOptions.Value.ApiCircuitBreakerErrorCount,
TimeSpan.FromMilliseconds(policyOptions.Value.ApiCircuitBreakerDelay));
this.apiExecutionSyncPolicy = val2.Execute(() => circuitBreakerApiPolicy);
var val3 = Policy.Handle <IOException>().WaitAndRetry(policyOptions.Value.QueueRetryCount,
attempt => TimeSpan.FromMilliseconds(policyOptions.Value.QueueRetryBaseDelay * attempt));
var circuitBreakerQueuePolicy = Policy.Handle <IOException>().CircuitBreaker(
policyOptions.Value.QueueCircuitBreakerErrorCount,
TimeSpan.FromMilliseconds(policyOptions.Value.QueueCircuitBreakerDelay));
this.queueExecutionSyncPolicy = val3.Execute(() => circuitBreakerQueuePolicy);
var val4 = Policy.Handle <Exception>().WaitAndRetry(policyOptions.Value.IORetryCount,
attempt => TimeSpan.FromMilliseconds(policyOptions.Value.IORetryBaseDelay * attempt));
var circuitBreakerIoPolicy = Policy.Handle <Exception>().CircuitBreaker(
policyOptions.Value.IOCircuitBreakerErrorCount,
TimeSpan.FromMilliseconds(policyOptions.Value.IOCircuitBreakerDelay));
this.ioExecutionSyncPolicy = val4.Execute(() => circuitBreakerIoPolicy);
}
/// <summary>
/// 重试处理
/// </summary>
private static void Retry()
{
int i = 0;
try
{
ISyncPolicy policy = Policy.Handle <Exception>()
.RetryForever();//一直重试
policy.Execute(() =>
{
Console.WriteLine("开始任务" + (++i));
if (DateTime.Now.Second % 2 != 0)
{
throw new Exception("出错");
}
Console.WriteLine("完成任务");
});
}
catch (Exception ex)
{
Console.WriteLine($"未处理异常:{ex}");
}
//RetryForever()是一直重试直到成功
//Retry()是重试最多一次；
//Retry(n)是重试最多n次；
//WaitAndRetry()可以实现“如果出错等待100ms再试还不行再等150ms秒。。。。”，重载方法很多，一看就懂，不再一一介绍。还有WaitAndRetryForever。
}
public static void RetryForever()
{
try
{
ISyncPolicy policy = Policy.Handle <Exception>()
//.WaitAndRetry(new TimeSpan[] { TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(2000) });
.RetryForever();
policy.Execute(() =>
{
Console.WriteLine("开始任务");
//if (Environment.TickCount % 2 == 0)
if (DateTime.Now.Second % 10 != 0)
{
throw new Exception("出错");
}
Console.WriteLine("完成任务");
});
}
catch (Exception ex)
{
Console.WriteLine("未处理异常" + ex);
}
}
/// <summary>
/// Polly简单使用
/// </summary>
private static void SimpleUse()
{
try
{
ISyncPolicy policy = Policy.Handle <ArgumentException>(ex => ex.Message == "年龄参数错误")
.Fallback(() =>
{
Console.WriteLine("出错了");
}, ex =>
{
Console.WriteLine("详细异常对象" + ex);
});
policy.Execute(() =>
{
//这里是可能会产生问题的业务系统代码
Console.WriteLine("开始任务");
throw new ArgumentException("年龄参数错误");
//throw new Exception("haha");
//Console.WriteLine("完成任务");
});
}
catch (Exception ex)
{
Console.WriteLine($"未处理异常:{ex}");
}
}
public BusinessLogic(ISomeService someService, ISyncPolicy policy)
{
_someService = someService;
_policy = policy;
Log.Information("BusinessLogic ctor done");
}
public void Converting_a_nongeneric_ISyncPolicy_to_generic_should_return_a_generic_ISyncPolicyTResult()
{
ISyncPolicy nonGenericPolicy = Policy.Timeout(10);
var genericPolicy = nonGenericPolicy.AsPolicy <ResultClass>();
genericPolicy.Should().BeAssignableTo <ISyncPolicy <ResultClass> >();
}
private ISyncPolicy CreateSyncPolicy(MethodInfo method)
{
List <IPolicyConfig> policyConfigs = GetPolicyConfigs(method);
ISyncPolicy policy = GetSyncPolicyConfigs(policyConfigs);
return(policy);
}
internal static TResult Implementation <TResult>(
Func <Context, CancellationToken, TResult> func,
Context context,
CancellationToken cancellationToken,
ISyncPolicy <TResult> outerPolicy,
ISyncPolicy <TResult> innerPolicy)
=> outerPolicy.Execute((ctx, ct) => innerPolicy.Execute(func, ctx, ct), context, cancellationToken);
public void Should_be_able_fluently_to_configure_the_policy_key_via_interface()
{
ISyncPolicy <int> policyAsInterface = Policy.HandleResult <int>(0).Retry();
var policyAsInterfaceAfterWithPolicyKey = policyAsInterface.WithPolicyKey(Guid.NewGuid().ToString());
policyAsInterfaceAfterWithPolicyKey.Should().BeAssignableTo <ISyncPolicy <int> >();
}
public PollyDbCommand(SqlCommand command, IAsyncPolicy[] asyncPolicies, ISyncPolicy[] syncPolicies)
{
_sqlCommand = command;
_sqlCommand.CommandTimeout = 5;
if (asyncPolicies == null)
{
throw new ArgumentNullException($"{nameof(asyncPolicies)} must have at least one async policy provided");
}
if (asyncPolicies.Length == 1)
{
_asyncSinglePolicy = asyncPolicies[0];
}
else
{
_asyncPolicyWrapper = Policy.WrapAsync(asyncPolicies);
}
if (syncPolicies == null)
{
throw new ArgumentNullException($"{nameof(syncPolicies)} must have at least one sync policy provided");
}
if (syncPolicies.Length == 1)
{
_syncSinglePolicy = syncPolicies[0];
}
else
{
_syncPolicyWrapper = Policy.Wrap(syncPolicies);
}
}
static void AdvancedCircuitBreaker()
{
Action <Exception, TimeSpan, Context> onBreak = (exception, timespan, context) =>
{
Console.WriteLine("onBreak Running,the exception.Message : " + exception.Message);
};
Action <Context> onReset = context =>
{
Console.WriteLine("Job Back to normal");
};
var breaker = Policy.Handle <ArgumentException>()
.AdvancedCircuitBreaker(
failureThreshold: 0.5, // Break on >=50% actions result in handled exceptions...
samplingDuration: TimeSpan.FromSeconds(3), // ... over any 10 second period
minimumThroughput: 3, // ... provided at least 8 actions in the 10 second period.
durationOfBreak: TimeSpan.FromSeconds(5), // Break for 30 seconds.
onBreak: onBreak, onReset: onReset);
ISyncPolicy policy = Policy.Handle <ArgumentException>()
.WaitAndRetry(new[] { TimeSpan.FromMilliseconds(200),
TimeSpan.FromMilliseconds(400) }, (ex, timesapn, context) =>
{
// Monitor the circuit state, for example for health reporting.
CircuitState state = breaker.CircuitState;
Console.WriteLine(state.ToString());
Console.WriteLine($"Runing Retry,Exception :{ex.Message},timesapn:{timesapn}");
});
while (true)
{
try
{
var policyWrap = Policy.Wrap(policy, breaker);
// (wraps the policies around any executed delegate: fallback outermost ... bulkhead innermost)
policyWrap.Execute(() =>
{
Console.WriteLine("Job Start");
if (DateTime.Now.Second % 2 == 0)
{
throw new ArgumentException("Hello Polly!");
}
});
}
catch (Exception ex)
{
// 手动打开熔断器，阻止执行
//breaker.Isolate();
}
Thread.Sleep(500);
// 恢复操作，启动执行
//breaker.Reset();
}
}
/// <summary>
/// Wraps the specified outer policy round the inner policy.
/// </summary>
/// <param name="outerPolicy">The outer policy.</param>
/// <param name="innerPolicy">The inner policy.</param>
/// <returns>A <see cref="PolicyWrap"/> instance representing the combined wrap.</returns>
public static PolicyWrap <TResult> Wrap <TResult>(this ISyncPolicy <TResult> outerPolicy, ISyncPolicy <TResult> innerPolicy)
{
if (outerPolicy == null)
{
throw new ArgumentNullException(nameof(outerPolicy));
}
return(((Policy <TResult>)outerPolicy).Wrap(innerPolicy));
}
public KafkaConsumerWrapper(IConsumer <string, TPayload> kafkaConsumer, IProducer <string, TPayload> kafkaProducer, ILogger <KafkaConsumerWrapper <TPayload> > logger)
{
this.kafkaConsumer = kafkaConsumer;
this.kafkaProducer = kafkaProducer;
this.logger = logger;
this.cancellationTokenSource = new CancellationTokenSource();
this.resiliencePolicy = CreateResiliencePolicy();
}
/// <summary>
/// Wraps the specified outer policy round the inner policy.
/// </summary>
/// <param name="outerPolicy">The outer policy.</param>
/// <param name="innerPolicy">The inner policy.</param>
/// <returns>A <see cref="PolicyWrap"/> instance representing the combined wrap.</returns>
public static PolicyWrap Wrap(this ISyncPolicy outerPolicy, ISyncPolicy innerPolicy)
{
if (outerPolicy == null)
{
throw new ArgumentNullException(nameof(outerPolicy));
}
return(((Policy)outerPolicy).Wrap(innerPolicy));
}
