AsyncFallbackPolicy
A fallback policy that can be applied to asynchronous delegates.
using Polly.Utilities;
using System;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Polly.Fallback
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
public class AsyncFallbackPolicy : AsyncPolicy, IFallbackPolicy, IsPolicy
{
private readonly Func<Exception, Context, Task> _onFallbackAsync;
private readonly Func<Exception, Context, CancellationToken, Task> _fallbackAction;
internal AsyncFallbackPolicy(PolicyBuilder policyBuilder, Func<Exception, Context, Task> onFallbackAsync, Func<Exception, Context, CancellationToken, Task> fallbackAction)
: base(policyBuilder)
{
if (onFallbackAsync == null)
throw new ArgumentNullException("onFallbackAsync");
_onFallbackAsync = onFallbackAsync;
if (fallbackAction == null)
throw new ArgumentNullException("fallbackAction");
_fallbackAction = fallbackAction;
}
protected override Task ImplementationAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
<>c__DisplayClass3_0 <>4__this;
return AsyncFallbackEngine.ImplementationAsync(delegate(Context ctx, CancellationToken ct) {
<>c__DisplayClass3_0.<<ImplementationAsync>b__0>d stateMachine2 = default(<>c__DisplayClass3_0.<<ImplementationAsync>b__0>d);
stateMachine2.<>t__builder = AsyncTaskMethodBuilder<EmptyStruct>.Create();
stateMachine2.<>4__this = <>4__this;
stateMachine2.ctx = ctx;
stateMachine2.ct = ct;
stateMachine2.<>1__state = -1;
stateMachine2.<>t__builder.Start(ref stateMachine2);
return stateMachine2.<>t__builder.Task;
}, context, base.ExceptionPredicates, ResultPredicates<EmptyStruct>.None, (DelegateResult<EmptyStruct> outcome, Context ctx) => _onFallbackAsync(outcome.Exception, ctx), delegate(DelegateResult<EmptyStruct> outcome, Context ctx, CancellationToken ct) {
<>c__DisplayClass3_0.<<ImplementationAsync>b__2>d stateMachine = default(<>c__DisplayClass3_0.<<ImplementationAsync>b__2>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<EmptyStruct>.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.ctx = ctx;
stateMachine.ct = ct;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}, continueOnCapturedContext, cancellationToken);
}
protected override Task<TResult> ImplementationAsync<[System.Runtime.CompilerServices.Nullable(0)] TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
throw new InvalidOperationException("You have executed the generic .Execute<TResult> method on a non-generic FallbackPolicy. A non-generic FallbackPolicy only defines a fallback action which returns void; it can never return a substitute TResult value. To use FallbackPolicy to provide fallback TResult values you must define a generic fallback policy FallbackPolicy<TResult>. For example, define the policy as Policy<TResult>.Handle<Whatever>.Fallback<TResult>(/* some TResult value or Func<..., TResult> */);");
}
}
}