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}");
}
}