AsyncPolicy<TResult>
Transient exception handling policies that can be applied to asynchronous delegates.
using Polly.Wrap;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Polly
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public abstract class AsyncPolicy<[System.Runtime.CompilerServices.Nullable(2)] TResult> : PolicyBase<TResult>, IAsyncPolicy<TResult>, IsPolicy
{
public AsyncPolicy<TResult> WithPolicyKey(string policyKey)
{
if (policyKeyInternal != null)
throw PolicyBase.PolicyKeyMustBeImmutableException("policyKey");
policyKeyInternal = policyKey;
return this;
}
IAsyncPolicy<TResult> IAsyncPolicy<TResult>.WithPolicyKey(string policyKey)
{
if (policyKeyInternal != null)
throw PolicyBase.PolicyKeyMustBeImmutableException("policyKey");
policyKeyInternal = policyKey;
return this;
}
protected abstract Task<TResult> ImplementationAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
[System.Runtime.CompilerServices.NullableContext(1)]
private protected AsyncPolicy(ExceptionPredicates exceptionPredicates, ResultPredicates<TResult> resultPredicates)
: base(exceptionPredicates, resultPredicates)
{
}
protected AsyncPolicy([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})] PolicyBuilder<TResult> policyBuilder = null)
: base(policyBuilder)
{
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Task<TResult>> action)
{
return ExecuteAsync((Context _, CancellationToken _) => action(), new Context(), CancellationToken.None, false);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Context, Task<TResult>> action, IDictionary<string, object> contextData)
{
return ExecuteAsync((Context ctx, CancellationToken _) => action(ctx), new Context(contextData), CancellationToken.None, false);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Context, Task<TResult>> action, Context context)
{
return ExecuteAsync((Context ctx, CancellationToken _) => action(ctx), context, CancellationToken.None, false);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken)
{
return ExecuteAsync((Context _, CancellationToken ct) => action(ct), new Context(), cancellationToken, false);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
return ExecuteAsync((Context _, CancellationToken ct) => action(ct), new Context(), cancellationToken, continueOnCapturedContext);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken)
{
return ExecuteAsync(action, new Context(contextData), cancellationToken, false);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken)
{
return ExecuteAsync(action, context, cancellationToken, false);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
return ExecuteAsync(action, new Context(contextData), cancellationToken, continueOnCapturedContext);
}
[DebuggerStepThrough]
public Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
if (context == null)
throw new ArgumentNullException("context");
return ExecuteInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Task<TResult>> action)
{
return ExecuteAndCaptureAsync((Context _, CancellationToken _) => action(), new Context(), CancellationToken.None, false);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, Task<TResult>> action, IDictionary<string, object> contextData)
{
return ExecuteAndCaptureAsync((Context ctx, CancellationToken _) => action(ctx), new Context(contextData), CancellationToken.None, false);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, Task<TResult>> action, Context context)
{
return ExecuteAndCaptureAsync((Context ctx, CancellationToken _) => action(ctx), context, CancellationToken.None, false);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken)
{
return ExecuteAndCaptureAsync((Context _, CancellationToken ct) => action(ct), new Context(), cancellationToken, false);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
return ExecuteAndCaptureAsync((Context _, CancellationToken ct) => action(ct), new Context(), cancellationToken, continueOnCapturedContext);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken)
{
return ExecuteAndCaptureAsync(action, new Context(contextData), cancellationToken, false);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken)
{
return ExecuteAndCaptureAsync(action, context, cancellationToken, false);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
return ExecuteAndCaptureAsync(action, new Context(contextData), cancellationToken, continueOnCapturedContext);
}
[DebuggerStepThrough]
public Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
if (context == null)
throw new ArgumentNullException("context");
return ExecuteAndCaptureInternalAsync(action, context, continueOnCapturedContext, cancellationToken);
}
[AsyncStateMachine(typeof(AsyncPolicy<>.<ExecuteInternalAsync>d__23))]
private Task<TResult> ExecuteInternalAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, bool continueOnCapturedContext, CancellationToken cancellationToken)
{
<ExecuteInternalAsync>d__23 stateMachine = default(<ExecuteInternalAsync>d__23);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<TResult>.Create();
stateMachine.<>4__this = this;
stateMachine.action = action;
stateMachine.context = context;
stateMachine.continueOnCapturedContext = continueOnCapturedContext;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(AsyncPolicy<>.<ExecuteAndCaptureInternalAsync>d__24))]
private Task<PolicyResult<TResult>> ExecuteAndCaptureInternalAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, bool continueOnCapturedContext, CancellationToken cancellationToken)
{
<ExecuteAndCaptureInternalAsync>d__24 stateMachine = default(<ExecuteAndCaptureInternalAsync>d__24);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<PolicyResult<TResult>>.Create();
stateMachine.<>4__this = this;
stateMachine.action = action;
stateMachine.context = context;
stateMachine.continueOnCapturedContext = continueOnCapturedContext;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public AsyncPolicyWrap<TResult> WrapAsync(IAsyncPolicy innerPolicy)
{
if (innerPolicy == null)
throw new ArgumentNullException("innerPolicy");
return new AsyncPolicyWrap<TResult>(this, innerPolicy);
}
public AsyncPolicyWrap<TResult> WrapAsync(IAsyncPolicy<TResult> innerPolicy)
{
if (innerPolicy == null)
throw new ArgumentNullException("innerPolicy");
return new AsyncPolicyWrap<TResult>(this, innerPolicy);
}
}
}