public void Should_call_onFallback_with_independent_context_for_independent_calls() { Func <Context, ResultPrimitive> fallbackAction = _ => ResultPrimitive.Substitute; IDictionary <ResultPrimitive, object> contextData = new Dictionary <ResultPrimitive, object>(); Action <DelegateResult <ResultPrimitive>, Context> onFallback = (dr, ctx) => { contextData[dr.Result] = ctx["key"]; }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .OrResult(ResultPrimitive.FaultAgain) .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(() => { return(ResultPrimitive.Fault); }, new { key = "value1" }.AsDictionary()) .Should().Be(ResultPrimitive.Substitute); fallbackPolicy.Execute(() => { return(ResultPrimitive.FaultAgain); }, new { key = "value2" }.AsDictionary()) .Should().Be(ResultPrimitive.Substitute); contextData.Count.Should().Be(2); contextData.Keys.Should().Contain(ResultPrimitive.Fault); contextData.Keys.Should().Contain(ResultPrimitive.FaultAgain); contextData[ResultPrimitive.Fault].Should().Be("value1"); contextData[ResultPrimitive.FaultAgain].Should().Be("value2"); }
public void Should_not_execute_fallback_when_execute_delegate_does_not_raise_fault() { bool fallbackActionExecuted = false; Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .Fallback(fallbackAction); fallbackPolicy.Execute(() => ResultPrimitive.Good); fallbackActionExecuted.Should().BeFalse(); }
public void Should_not_execute_fallback_when_execute_delegate_does_not_throw() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction); fallbackPolicy.Execute(() => { }); fallbackActionExecuted.Should().BeFalse(); }
public static void FallingBack() { ErrorProneCode errorProneCode = new ErrorProneCode(); #region fallingBack FallbackPolicy fallbackPolicy = Policy.Handle <Exception>() .Fallback(() => PageAnAdmin()); fallbackPolicy.Execute(() => errorProneCode.MakeRequestToADeadService()); #endregion }
public static void FallingBackAndReturningADefault() { ErrorProneCode errorProneCode = new ErrorProneCode(); #region fallingBackAndReturningADefault FallbackPolicy <int> fallbackPolicy = Policy <int> .Handle <Exception>() .Fallback <int>(0); int quantity = fallbackPolicy.Execute(() => errorProneCode.GetQuantityAvailable()); Console.WriteLine($"{quantity} items available."); #endregion }
public void Should_not_call_onFallback_when_execute_delegate_does_not_raise_fault() { Func <ResultPrimitive> fallbackAction = () => ResultPrimitive.Substitute; bool onFallbackExecuted = false; Action <DelegateResult <ResultPrimitive> > onFallback = _ => { onFallbackExecuted = true; }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(() => ResultPrimitive.Good); onFallbackExecuted.Should().BeFalse(); }
public void Should_not_call_onFallback_when_execute_delegate_does_not_throw() { Action fallbackAction = () => { }; bool onFallbackExecuted = false; Action <Exception> onFallback = _ => { onFallbackExecuted = true; }; FallbackPolicy fallbackPolicy = Policy .Handle <DivideByZeroException>() .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(() => { }); onFallbackExecuted.Should().BeFalse(); }
public void Print() { try { fallbackPolicy.Execute((context) => { int a = 10; int j = a / 0; }, new Context("Print with Polly Fallback", new Dictionary <string, object> { { "a", 10 } })); } catch (Exception) { throw; } }
public void Should_not_call_fallbackAction_with_the_fault_if_fault_unhandled() { DelegateResult <ResultPrimitive> fallbackOutcome = null; Func <DelegateResult <ResultPrimitive>, Context, CancellationToken, ResultPrimitive> fallbackAction = (outcome, ctx, ct) => { fallbackOutcome = outcome; return(ResultPrimitive.Substitute); }; Action <DelegateResult <ResultPrimitive>, Context> onFallback = (ex, ctx) => { }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy <ResultPrimitive> .HandleResult(ResultPrimitive.Fault) .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(() => { return(ResultPrimitive.FaultAgain); }) .Should().Be(ResultPrimitive.FaultAgain); fallbackOutcome.Should().BeNull(); }
public void Should_call_fallbackAction_with_the_passed_context() { IDictionary <string, object> contextData = null; Func <Context, CancellationToken, ResultPrimitive> fallbackAction = (ctx, ct) => { contextData = ctx; return(ResultPrimitive.Substitute); }; Action <DelegateResult <ResultPrimitive>, Context> onFallback = (ex, ctx) => { }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy <ResultPrimitive> .HandleResult(ResultPrimitive.Fault) .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(() => { return(ResultPrimitive.Fault); }, new { key1 = "value1", key2 = "value2" }.AsDictionary()) .Should().Be(ResultPrimitive.Substitute); contextData.Should() .ContainKeys("key1", "key2").And .ContainValues("value1", "value2"); }
public void Should_call_onFallback_passing_result_triggering_fallback() { bool fallbackActionExecuted = false; Func <ResultClass> fallbackAction = () => { fallbackActionExecuted = true; return(new ResultClass(ResultPrimitive.Substitute)); }; ResultClass resultPassedToOnFallback = null; Action <DelegateResult <ResultClass> > onFallback = r => { resultPassedToOnFallback = r.Result; }; FallbackPolicy <ResultClass> fallbackPolicy = Policy .HandleResult <ResultClass>(r => r.ResultCode == ResultPrimitive.Fault) .Fallback(fallbackAction, onFallback); ResultClass resultFromDelegate = new ResultClass(ResultPrimitive.Fault); fallbackPolicy.Execute(() => { return(resultFromDelegate); }); fallbackActionExecuted.Should().BeTrue(); resultPassedToOnFallback.Should().NotBeNull(); resultPassedToOnFallback.Should().Be(resultFromDelegate); }
public void Should_call_fallbackAction_with_the_fault() { DelegateResult <ResultPrimitive> fallbackOutcome = null; Func <DelegateResult <ResultPrimitive>, Context, CancellationToken, ResultPrimitive> fallbackAction = (outcome, _, _) => { fallbackOutcome = outcome; return(ResultPrimitive.Substitute); }; Action <DelegateResult <ResultPrimitive>, Context> onFallback = (_, _) => { }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy <ResultPrimitive> .HandleResult(ResultPrimitive.Fault) .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(() => ResultPrimitive.Fault) .Should().Be(ResultPrimitive.Substitute); fallbackOutcome.Should().NotBeNull(); fallbackOutcome.Exception.Should().BeNull(); fallbackOutcome.Result.Should().Be(ResultPrimitive.Fault); }
public void Should_call_onFallback_with_the_passed_context() { Func <Context, ResultPrimitive> fallbackAction = _ => ResultPrimitive.Substitute; IDictionary <string, object> contextData = null; Action <DelegateResult <ResultPrimitive>, Context> onFallback = (_, ctx) => { contextData = ctx; }; FallbackPolicy <ResultPrimitive> fallbackPolicy = Policy .HandleResult(ResultPrimitive.Fault) .Fallback(fallbackAction, onFallback); fallbackPolicy.Execute(_ => ResultPrimitive.Fault, new { key1 = "value1", key2 = "value2" }.AsDictionary()) .Should().Be(ResultPrimitive.Substitute); contextData.Should() .ContainKeys("key1", "key2").And .ContainValues("value1", "value2"); }
public void Should_call_onFallback_passing_exception_triggering_fallback() { bool fallbackActionExecuted = false; Action fallbackAction = () => { fallbackActionExecuted = true; }; Exception exceptionPassedToOnFallback = null; Action <Exception> onFallback = ex => { exceptionPassedToOnFallback = ex; }; FallbackPolicy fallbackPolicy = Policy .Handle <ArgumentNullException>() .Fallback(fallbackAction, onFallback); Exception instanceToThrow = new ArgumentNullException("myParam"); fallbackPolicy.Execute(() => { throw instanceToThrow; }); fallbackActionExecuted.Should().BeTrue(); exceptionPassedToOnFallback.Should().BeOfType <ArgumentNullException>(); exceptionPassedToOnFallback.Should().Be(instanceToThrow); }
public static void Test2() { FallbackPolicy <string> policy = Policy <string> .Handle <ArgumentNullException>() .Fallback("匿名"); try { for (int i = 0; i < 3; i++) { string result = policy.Execute(() => { return(GetUserName(i == 0 ? null : (int?)i)); }); Console.WriteLine($"用户名是:{result}"); } } catch (Exception ex) { Console.WriteLine($"异常信息:{ex.Message}"); } }