ResiliencePipeline
Resilience pipeline is used to execute the user-provided callbacks.
using Polly.Utils;
using Polly.Utils.Pipeline;
using System;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Polly
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
public sealed class ResiliencePipeline
{
public static readonly ResiliencePipeline Empty = new ResiliencePipeline(PipelineComponent.Empty, DisposeBehavior.Ignore);
internal static ResilienceContextPool Pool => ResilienceContextPool.Shared;
internal PipelineComponent Component { get; }
internal ComponentDisposeHelper DisposeHelper { get; }
[AsyncStateMachine(typeof(<ExecuteAsync>d__0<>))]
public ValueTask ExecuteAsync<[System.Runtime.CompilerServices.Nullable(2)] TState>(Func<ResilienceContext, TState, ValueTask> callback, ResilienceContext context, TState state)
{
<ExecuteAsync>d__0<TState> stateMachine = default(<ExecuteAsync>d__0<TState>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.context = context;
stateMachine.state = state;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<ExecuteAsync>d__1))]
public ValueTask ExecuteAsync(Func<ResilienceContext, ValueTask> callback, ResilienceContext context)
{
<ExecuteAsync>d__1 stateMachine = default(<ExecuteAsync>d__1);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.context = context;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<ExecuteAsync>d__2<>))]
public ValueTask ExecuteAsync<[System.Runtime.CompilerServices.Nullable(2)] TState>(Func<TState, CancellationToken, ValueTask> callback, TState state, CancellationToken cancellationToken = default(CancellationToken))
{
<ExecuteAsync>d__2<TState> stateMachine = default(<ExecuteAsync>d__2<TState>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.state = state;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<ExecuteAsync>d__3))]
public ValueTask ExecuteAsync(Func<CancellationToken, ValueTask> callback, CancellationToken cancellationToken = default(CancellationToken))
{
<ExecuteAsync>d__3 stateMachine = default(<ExecuteAsync>d__3);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
private ResilienceContext GetAsyncContext(CancellationToken cancellationToken)
{
return GetAsyncContext<VoidResult>(cancellationToken);
}
private void InitializeAsyncContext(ResilienceContext context)
{
InitializeAsyncContext<VoidResult>(context);
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})]
public ValueTask<Outcome<TResult>> ExecuteOutcomeAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult, [System.Runtime.CompilerServices.Nullable(2)] TState>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
1,
1,
0,
0,
1
})] Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
{
Guard.NotNull(callback, "callback");
Guard.NotNull(context, "context");
InitializeAsyncContext<TResult>(context);
return Component.ExecuteCore(callback, context, state);
}
[AsyncStateMachine(typeof(<ExecuteAsync>d__7<, >))]
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public ValueTask<TResult> ExecuteAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult, [System.Runtime.CompilerServices.Nullable(2)] TState>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
1,
1,
0,
1
})] Func<ResilienceContext, TState, ValueTask<TResult>> callback, ResilienceContext context, TState state)
{
<ExecuteAsync>d__7<TResult, TState> stateMachine = default(<ExecuteAsync>d__7<TResult, TState>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<TResult>.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.context = context;
stateMachine.state = state;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<ExecuteAsync>d__8<>))]
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public ValueTask<TResult> ExecuteAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
1,
0,
1
})] Func<ResilienceContext, ValueTask<TResult>> callback, ResilienceContext context)
{
<ExecuteAsync>d__8<TResult> stateMachine = default(<ExecuteAsync>d__8<TResult>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<TResult>.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.context = context;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[System.Runtime.CompilerServices.NullableContext(2)]
[AsyncStateMachine(typeof(<ExecuteAsync>d__9<, >))]
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public ValueTask<TResult> ExecuteAsync<TResult, TState>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
1,
0,
1
})] Func<TState, CancellationToken, ValueTask<TResult>> callback, [System.Runtime.CompilerServices.Nullable(1)] TState state, CancellationToken cancellationToken = default(CancellationToken))
{
<ExecuteAsync>d__9<TResult, TState> stateMachine = default(<ExecuteAsync>d__9<TResult, TState>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<TResult>.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.state = state;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[System.Runtime.CompilerServices.NullableContext(2)]
[AsyncStateMachine(typeof(<ExecuteAsync>d__10<>))]
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public ValueTask<TResult> ExecuteAsync<TResult>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1
})] Func<CancellationToken, ValueTask<TResult>> callback, CancellationToken cancellationToken = default(CancellationToken))
{
<ExecuteAsync>d__10<TResult> stateMachine = default(<ExecuteAsync>d__10<TResult>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<TResult>.Create();
stateMachine.<>4__this = this;
stateMachine.callback = callback;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
private ResilienceContext GetAsyncContext<[System.Runtime.CompilerServices.Nullable(2)] TResult>(CancellationToken cancellationToken)
{
ResilienceContext resilienceContext = Pool.Get(cancellationToken);
InitializeAsyncContext<TResult>(resilienceContext);
return resilienceContext;
}
private void InitializeAsyncContext<[System.Runtime.CompilerServices.Nullable(2)] TResult>(ResilienceContext context)
{
DisposeHelper.EnsureNotDisposed();
context.Initialize<TResult>(false);
}
internal ResiliencePipeline(PipelineComponent component, DisposeBehavior disposeBehavior)
{
Component = component;
DisposeHelper = new ComponentDisposeHelper(component, disposeBehavior);
}
public void Execute<[System.Runtime.CompilerServices.Nullable(2)] TState>(Action<ResilienceContext, TState> callback, ResilienceContext context, TState state)
{
Guard.NotNull(callback, "callback");
Guard.NotNull(context, "context");
InitializeSyncContext(context);
Component.ExecuteCoreSync(delegate(ResilienceContext context, (Action<ResilienceContext, TState> callback, TState state) state) {
try {
state.callback(context, state.state);
return Outcome.Void;
} catch (Exception exception) {
return Outcome.FromException(exception);
}
}, context, (callback, state)).GetResultOrRethrow();
}
public void Execute(Action<ResilienceContext> callback, ResilienceContext context)
{
Guard.NotNull(callback, "callback");
Guard.NotNull(context, "context");
InitializeSyncContext(context);
Component.ExecuteCoreSync(delegate(ResilienceContext context, Action<ResilienceContext> state) {
try {
state(context);
return Outcome.Void;
} catch (Exception exception) {
return Outcome.FromException(exception);
}
}, context, callback).GetResultOrRethrow();
}
public void Execute<[System.Runtime.CompilerServices.Nullable(2)] TState>(Action<TState, CancellationToken> callback, TState state, CancellationToken cancellationToken = default(CancellationToken))
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext(cancellationToken);
try {
Component.ExecuteCoreSync(delegate(ResilienceContext context, (Action<TState, CancellationToken> callback, TState state) state) {
try {
state.callback(state.state, context.CancellationToken);
return Outcome.Void;
} catch (Exception exception) {
return Outcome.FromException(exception);
}
}, syncContext, (callback, state)).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
public void Execute(Action<CancellationToken> callback, CancellationToken cancellationToken = default(CancellationToken))
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext(cancellationToken);
try {
Component.ExecuteCoreSync(delegate(ResilienceContext context, Action<CancellationToken> state) {
try {
state(context.CancellationToken);
return Outcome.Void;
} catch (Exception exception) {
return Outcome.FromException(exception);
}
}, syncContext, callback).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
public void Execute<[System.Runtime.CompilerServices.Nullable(2)] TState>(Action<TState> callback, TState state)
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext(CancellationToken.None);
try {
Component.ExecuteCoreSync(delegate(ResilienceContext _, (Action<TState> callback, TState state) state) {
try {
state.callback(state.state);
return Outcome.Void;
} catch (Exception exception) {
return Outcome.FromException(exception);
}
}, syncContext, (callback, state)).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
public void Execute(Action callback)
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext(CancellationToken.None);
try {
Component.ExecuteCoreSync(delegate(ResilienceContext _, Action state) {
try {
state();
return Outcome.Void;
} catch (Exception exception) {
return Outcome.FromException(exception);
}
}, syncContext, callback).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
private ResilienceContext GetSyncContext(CancellationToken cancellationToken)
{
return GetSyncContext<VoidResult>(cancellationToken);
}
private void InitializeSyncContext(ResilienceContext context)
{
InitializeSyncContext<VoidResult>(context);
}
public TResult Execute<[System.Runtime.CompilerServices.Nullable(2)] TResult, [System.Runtime.CompilerServices.Nullable(2)] TState>(Func<ResilienceContext, TState, TResult> callback, ResilienceContext context, TState state)
{
Guard.NotNull(callback, "callback");
Guard.NotNull(context, "context");
InitializeSyncContext<TResult>(context);
return Component.ExecuteCoreSync(delegate(ResilienceContext context, (Func<ResilienceContext, TState, TResult> callback, TState state) state) {
try {
return Outcome.FromResult<TResult>(state.callback(context, state.state));
} catch (Exception exception) {
return Outcome.FromException<TResult>(exception);
}
}, context, (callback, state)).GetResultOrRethrow();
}
public TResult Execute<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<ResilienceContext, TResult> callback, ResilienceContext context)
{
Guard.NotNull(callback, "callback");
Guard.NotNull(context, "context");
InitializeSyncContext<TResult>(context);
return Component.ExecuteCoreSync(delegate(ResilienceContext context, Func<ResilienceContext, TResult> state) {
try {
return Outcome.FromResult<TResult>(state(context));
} catch (Exception exception) {
return Outcome.FromException<TResult>(exception);
}
}, context, callback).GetResultOrRethrow();
}
public TResult Execute<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<CancellationToken, TResult> callback, CancellationToken cancellationToken = default(CancellationToken))
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext<TResult>(cancellationToken);
try {
return Component.ExecuteCoreSync(delegate(ResilienceContext context, Func<CancellationToken, TResult> state) {
try {
return Outcome.FromResult<TResult>(state(context.CancellationToken));
} catch (Exception exception) {
return Outcome.FromException<TResult>(exception);
}
}, syncContext, callback).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
public TResult Execute<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<TResult> callback)
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext<TResult>(CancellationToken.None);
try {
return Component.ExecuteCoreSync(delegate(ResilienceContext _, Func<TResult> state) {
try {
return Outcome.FromResult<TResult>(state());
} catch (Exception exception) {
return Outcome.FromException<TResult>(exception);
}
}, syncContext, callback).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
public TResult Execute<[System.Runtime.CompilerServices.Nullable(2)] TResult, [System.Runtime.CompilerServices.Nullable(2)] TState>(Func<TState, TResult> callback, TState state)
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext<TResult>(CancellationToken.None);
try {
return Component.ExecuteCoreSync(delegate(ResilienceContext _, (Func<TState, TResult> callback, TState state) state) {
try {
return Outcome.FromResult<TResult>(state.callback(state.state));
} catch (Exception exception) {
return Outcome.FromException<TResult>(exception);
}
}, syncContext, (callback, state)).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
public TResult Execute<[System.Runtime.CompilerServices.Nullable(2)] TResult, [System.Runtime.CompilerServices.Nullable(2)] TState>(Func<TState, CancellationToken, TResult> callback, TState state, CancellationToken cancellationToken = default(CancellationToken))
{
Guard.NotNull(callback, "callback");
ResilienceContext syncContext = GetSyncContext<TResult>(cancellationToken);
try {
return Component.ExecuteCoreSync(delegate(ResilienceContext context, (Func<TState, CancellationToken, TResult> callback, TState state) state) {
try {
return Outcome.FromResult<TResult>(state.callback(state.state, context.CancellationToken));
} catch (Exception exception) {
return Outcome.FromException<TResult>(exception);
}
}, syncContext, (callback, state)).GetResultOrRethrow();
} finally {
Pool.Return(syncContext);
}
}
private ResilienceContext GetSyncContext<[System.Runtime.CompilerServices.Nullable(2)] TResult>(CancellationToken cancellationToken)
{
ResilienceContext resilienceContext = Pool.Get(cancellationToken);
InitializeSyncContext<TResult>(resilienceContext);
return resilienceContext;
}
private void InitializeSyncContext<[System.Runtime.CompilerServices.Nullable(2)] TResult>(ResilienceContext context)
{
DisposeHelper.EnsureNotDisposed();
context.Initialize<TResult>(true);
}
}
}