OutcomeResilienceStrategy<T>
This base strategy class is used to simplify the implementation of generic (reactive)
strategies by limiting the number of generic types this strategy receives.
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
namespace Polly.Utils
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
internal abstract class OutcomeResilienceStrategy<[System.Runtime.CompilerServices.Nullable(2)] T> : ResilienceStrategy
{
private readonly bool _isGeneric;
protected OutcomeResilienceStrategy(bool isGeneric)
{
if (!isGeneric && typeof(T) != typeof(object))
throw new NotSupportedException("For non-generic strategies the generic parameter should be of type 'object'.");
_isGeneric = isGeneric;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})]
protected internal sealed override ValueTask<Outcome<TResult>> ExecuteCoreAsync<[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)
{
if (this._isGeneric) {
if (typeof(TResult) != typeof(T))
return callback(context, state);
Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback2 = (Func<ResilienceContext, TState, ValueTask<Outcome<T>>>)callback;
return ConvertValueTask<TResult>(ExecuteCallbackAsync(callback2, context, state), context);
}
return ConvertValueTask<TResult>(ExecuteCallbackAsync(delegate(ResilienceContext context, (Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, TState state) state) {
<>c__2<TResult, TState>.<<ExecuteCoreAsync>b__2_0>d stateMachine = default(<>c__2<TResult, TState>.<<ExecuteCoreAsync>b__2_0>d);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<Outcome<T>>.Create();
stateMachine.context = context;
stateMachine.state = state;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}, context, (callback, state)), context);
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})]
protected abstract ValueTask<Outcome<T>> ExecuteCallbackAsync<[System.Runtime.CompilerServices.Nullable(2)] TState>([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
1,
1,
0,
0,
1
})] Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback, ResilienceContext context, TState state);
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})]
private static ValueTask<Outcome<TResult>> ConvertValueTask<[System.Runtime.CompilerServices.Nullable(2)] TResult>([System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})] ValueTask<Outcome<T>> valueTask, ResilienceContext resilienceContext)
{
if (valueTask.IsCompletedSuccessfully)
return new ValueTask<Outcome<TResult>>(valueTask.Result.AsOutcome<TResult>());
return <ConvertValueTask>g__ConvertValueTaskAsync|4_0<TResult>(valueTask, resilienceContext);
}
}
}