AsyncRetryTResultSyntax
using Polly.Retry;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
namespace Polly
{
public static class AsyncRetryTResultSyntax
{
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder)
{
return policyBuilder.RetryAsync(1);
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount)
{
Action<DelegateResult<TResult>, int> onRetry = delegate {
};
return policyBuilder.RetryAsync(retryCount, onRetry);
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>, int> onRetry)
{
<>c__DisplayClass2_0<TResult> <>4__this;
return policyBuilder.RetryAsync(1, delegate(DelegateResult<TResult> outcome, int i, Context _) {
<>c__DisplayClass2_0<TResult>.<<RetryAsync>b__0>d stateMachine = default(<>c__DisplayClass2_0<TResult>.<<RetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.i = i;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass2_0<TResult>.<<RetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<DelegateResult<TResult>, int, Task> onRetryAsync)
{
return policyBuilder.RetryAsync(1, (DelegateResult<TResult> outcome, int i, Context _) => onRetryAsync(outcome, i));
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Action<DelegateResult<TResult>, int> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass4_0<TResult> <>4__this;
return policyBuilder.RetryAsync(retryCount, delegate(DelegateResult<TResult> outcome, int i, Context _) {
<>c__DisplayClass4_0<TResult>.<<RetryAsync>b__0>d stateMachine = default(<>c__DisplayClass4_0<TResult>.<<RetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.i = i;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass4_0<TResult>.<<RetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<DelegateResult<TResult>, int, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.RetryAsync(retryCount, (DelegateResult<TResult> outcome, int i, Context _) => onRetryAsync(outcome, i));
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>, int, Context> onRetry)
{
return policyBuilder.RetryAsync(1, onRetry);
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<DelegateResult<TResult>, int, Context, Task> onRetryAsync)
{
return policyBuilder.RetryAsync(1, onRetryAsync);
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Action<DelegateResult<TResult>, int, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass8_0<TResult> <>4__this;
return policyBuilder.RetryAsync(retryCount, delegate(DelegateResult<TResult> outcome, int i, Context ctx) {
<>c__DisplayClass8_0<TResult>.<<RetryAsync>b__0>d stateMachine = default(<>c__DisplayClass8_0<TResult>.<<RetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.i = i;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass8_0<TResult>.<<RetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<DelegateResult<TResult>, int, Context, Task> onRetryAsync)
{
if (retryCount < 0)
throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero.");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, (Func<DelegateResult<TResult>, TimeSpan, int, Context, Task>)((DelegateResult<TResult> outcome, TimeSpan _, int i, Context ctx) => onRetryAsync(outcome, i, ctx)), retryCount, (IEnumerable<TimeSpan>)null, (Func<int, DelegateResult<TResult>, Context, TimeSpan>)null);
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder)
{
Action<DelegateResult<TResult>> onRetry = delegate {
};
return policyBuilder.RetryForeverAsync(onRetry);
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass11_0<TResult> <>4__this;
return policyBuilder.RetryForeverAsync(delegate(DelegateResult<TResult> outcome, Context _) {
<>c__DisplayClass11_0<TResult>.<<RetryForeverAsync>b__0>d stateMachine = default(<>c__DisplayClass11_0<TResult>.<<RetryForeverAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass11_0<TResult>.<<RetryForeverAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>, int> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass12_0<TResult> <>4__this;
return policyBuilder.RetryForeverAsync(delegate(DelegateResult<TResult> outcome, int i, Context _) {
<>c__DisplayClass12_0<TResult>.<<RetryForeverAsync>b__0>d stateMachine = default(<>c__DisplayClass12_0<TResult>.<<RetryForeverAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.i = i;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass12_0<TResult>.<<RetryForeverAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<DelegateResult<TResult>, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.RetryForeverAsync((DelegateResult<TResult> outcome, Context _) => onRetryAsync(outcome));
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<DelegateResult<TResult>, int, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.RetryForeverAsync((DelegateResult<TResult> outcome, int i, Context _) => onRetryAsync(outcome, i));
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass15_0<TResult> <>4__this;
return policyBuilder.RetryForeverAsync(delegate(DelegateResult<TResult> outcome, Context ctx) {
<>c__DisplayClass15_0<TResult>.<<RetryForeverAsync>b__0>d stateMachine = default(<>c__DisplayClass15_0<TResult>.<<RetryForeverAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass15_0<TResult>.<<RetryForeverAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>, int, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass16_0<TResult> <>4__this;
return policyBuilder.RetryForeverAsync(delegate(DelegateResult<TResult> outcome, int i, Context ctx) {
<>c__DisplayClass16_0<TResult>.<<RetryForeverAsync>b__0>d stateMachine = default(<>c__DisplayClass16_0<TResult>.<<RetryForeverAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.i = i;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass16_0<TResult>.<<RetryForeverAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<DelegateResult<TResult>, Context, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, (Func<DelegateResult<TResult>, TimeSpan, int, Context, Task>)((DelegateResult<TResult> outcome, TimeSpan _, int _, Context ctx) => onRetryAsync(outcome, ctx)), 2147483647, (IEnumerable<TimeSpan>)null, (Func<int, DelegateResult<TResult>, Context, TimeSpan>)null);
}
public static AsyncRetryPolicy<TResult> RetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<DelegateResult<TResult>, int, Context, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, (Func<DelegateResult<TResult>, TimeSpan, int, Context, Task>)((DelegateResult<TResult> outcome, TimeSpan _, int i, Context ctx) => onRetryAsync(outcome, i, ctx)), 2147483647, (IEnumerable<TimeSpan>)null, (Func<int, DelegateResult<TResult>, Context, TimeSpan>)null);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider)
{
Action<DelegateResult<TResult>, TimeSpan> onRetry = delegate {
};
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, onRetry);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass20_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, delegate(DelegateResult<TResult> outcome, TimeSpan span, int _, Context _) {
<>c__DisplayClass20_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass20_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.span = span;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass20_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, (DelegateResult<TResult> outcome, TimeSpan span, int _, Context _) => onRetryAsync(outcome, span));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass22_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, delegate(DelegateResult<TResult> outcome, TimeSpan span, int _, Context ctx) {
<>c__DisplayClass22_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass22_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.span = span;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass22_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, Context, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, (DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context ctx) => onRetryAsync(outcome, timespan, ctx));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan, int, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass24_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, delegate(DelegateResult<TResult> outcome, TimeSpan timespan, int i, Context ctx) {
<>c__DisplayClass24_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass24_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.timespan = timespan;
stateMachine.i = i;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass24_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, int, Context, Task> onRetryAsync)
{
if (retryCount < 0)
throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero.");
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
IEnumerable<TimeSpan> sleepDurationsEnumerable = Enumerable.Range(1, retryCount).Select(sleepDurationProvider);
return new AsyncRetryPolicy<TResult>(policyBuilder, onRetryAsync, retryCount, sleepDurationsEnumerable, (Func<int, DelegateResult<TResult>, Context, TimeSpan>)null);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, Context, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass26_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, delegate(DelegateResult<TResult> outcome, TimeSpan span, int _, Context ctx) {
<>c__DisplayClass26_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass26_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.span = span;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass26_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, Context, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, (DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context ctx) => onRetryAsync(outcome, timespan, ctx));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, Context, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan, int, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass28_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(retryCount, sleepDurationProvider, delegate(DelegateResult<TResult> outcome, TimeSpan timespan, int i, Context ctx) {
<>c__DisplayClass28_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass28_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.timespan = timespan;
stateMachine.i = i;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass28_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, int, Context, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
return policyBuilder.WaitAndRetryAsync(retryCount, (int i, DelegateResult<TResult> _, Context ctx) => sleepDurationProvider(i, ctx), onRetryAsync);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, int retryCount, Func<int, DelegateResult<TResult>, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, int, Context, Task> onRetryAsync)
{
if (retryCount < 0)
throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero.");
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, onRetryAsync, retryCount, (IEnumerable<TimeSpan>)null, sleepDurationProvider);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations)
{
Action<DelegateResult<TResult>, TimeSpan> onRetry = delegate {
};
return policyBuilder.WaitAndRetryAsync(sleepDurations, onRetry);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations, Action<DelegateResult<TResult>, TimeSpan> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass32_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(sleepDurations, delegate(DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context _) {
<>c__DisplayClass32_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass32_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.timespan = timespan;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass32_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations, Func<DelegateResult<TResult>, TimeSpan, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryAsync(sleepDurations, (DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context _) => onRetryAsync(outcome, timespan));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations, Action<DelegateResult<TResult>, TimeSpan, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass34_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(sleepDurations, delegate(DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context ctx) {
<>c__DisplayClass34_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass34_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.timespan = timespan;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass34_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations, Func<DelegateResult<TResult>, TimeSpan, Context, Task> onRetryAsync)
{
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryAsync(sleepDurations, (DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context ctx) => onRetryAsync(outcome, timespan, ctx));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations, Action<DelegateResult<TResult>, TimeSpan, int, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass36_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryAsync(sleepDurations, delegate(DelegateResult<TResult> outcome, TimeSpan timespan, int i, Context ctx) {
<>c__DisplayClass36_0<TResult>.<<WaitAndRetryAsync>b__0>d stateMachine = default(<>c__DisplayClass36_0<TResult>.<<WaitAndRetryAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.timespan = timespan;
stateMachine.i = i;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass36_0<TResult>.<<WaitAndRetryAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, IEnumerable<TimeSpan> sleepDurations, Func<DelegateResult<TResult>, TimeSpan, int, Context, Task> onRetryAsync)
{
if (sleepDurations == null)
throw new ArgumentNullException("sleepDurations");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, onRetryAsync, 2147483647, sleepDurations, (Func<int, DelegateResult<TResult>, Context, TimeSpan>)null);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, TimeSpan> sleepDurationProvider)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
Action<DelegateResult<TResult>, TimeSpan> onRetry = delegate {
};
return policyBuilder.WaitAndRetryForeverAsync(sleepDurationProvider, onRetry);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, Context, TimeSpan> sleepDurationProvider)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
Action<DelegateResult<TResult>, TimeSpan, Context> onRetry = delegate {
};
return policyBuilder.WaitAndRetryForeverAsync(sleepDurationProvider, onRetry);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan> onRetry)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetry == null)
throw new ArgumentNullException("onRetry");
return policyBuilder.WaitAndRetryForeverAsync((int retryCount, Context _) => sleepDurationProvider(retryCount), delegate(DelegateResult<TResult> outcome, TimeSpan timespan, Context _) {
onRetry(outcome, timespan);
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, int, TimeSpan> onRetry)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetry == null)
throw new ArgumentNullException("onRetry");
return policyBuilder.WaitAndRetryForeverAsync((int retryCount, Context _) => sleepDurationProvider(retryCount), delegate(DelegateResult<TResult> outcome, int i, TimeSpan timespan, Context _) {
onRetry(outcome, i, timespan);
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryForeverAsync((int retryCount, Context _) => sleepDurationProvider(retryCount), (DelegateResult<TResult> outcome, TimeSpan timespan, Context _) => onRetryAsync(outcome, timespan));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, int, TimeSpan, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return policyBuilder.WaitAndRetryForeverAsync((int retryCount, Context _) => sleepDurationProvider(retryCount), (DelegateResult<TResult> outcome, int i, TimeSpan timespan, Context _) => onRetryAsync(outcome, i, timespan));
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, Context, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, TimeSpan, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass44_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryForeverAsync(sleepDurationProvider, delegate(DelegateResult<TResult> outcome, TimeSpan timespan, Context ctx) {
<>c__DisplayClass44_0<TResult>.<<WaitAndRetryForeverAsync>b__0>d stateMachine = default(<>c__DisplayClass44_0<TResult>.<<WaitAndRetryForeverAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.timespan = timespan;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass44_0<TResult>.<<WaitAndRetryForeverAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, Context, TimeSpan> sleepDurationProvider, Action<DelegateResult<TResult>, int, TimeSpan, Context> onRetry)
{
if (onRetry == null)
throw new ArgumentNullException("onRetry");
<>c__DisplayClass45_0<TResult> <>4__this;
return policyBuilder.WaitAndRetryForeverAsync(sleepDurationProvider, delegate(DelegateResult<TResult> outcome, int i, TimeSpan timespan, Context ctx) {
<>c__DisplayClass45_0<TResult>.<<WaitAndRetryForeverAsync>b__0>d stateMachine = default(<>c__DisplayClass45_0<TResult>.<<WaitAndRetryForeverAsync>b__0>d);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = <>4__this;
stateMachine.outcome = outcome;
stateMachine.i = i;
stateMachine.timespan = timespan;
stateMachine.ctx = ctx;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start<<>c__DisplayClass45_0<TResult>.<<WaitAndRetryForeverAsync>b__0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, Context, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
return policyBuilder.WaitAndRetryForeverAsync((int i, DelegateResult<TResult> _, Context ctx) => sleepDurationProvider(i, ctx), onRetryAsync);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, int, TimeSpan, Context, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
return policyBuilder.WaitAndRetryForeverAsync((int i, DelegateResult<TResult> _, Context ctx) => sleepDurationProvider(i, ctx), onRetryAsync);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, DelegateResult<TResult>, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, TimeSpan, Context, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, (Func<DelegateResult<TResult>, TimeSpan, int, Context, Task>)((DelegateResult<TResult> outcome, TimeSpan timespan, int _, Context ctx) => onRetryAsync(outcome, timespan, ctx)), 2147483647, (IEnumerable<TimeSpan>)null, sleepDurationProvider);
}
public static AsyncRetryPolicy<TResult> WaitAndRetryForeverAsync<TResult>(this PolicyBuilder<TResult> policyBuilder, Func<int, DelegateResult<TResult>, Context, TimeSpan> sleepDurationProvider, Func<DelegateResult<TResult>, int, TimeSpan, Context, Task> onRetryAsync)
{
if (sleepDurationProvider == null)
throw new ArgumentNullException("sleepDurationProvider");
if (onRetryAsync == null)
throw new ArgumentNullException("onRetryAsync");
return new AsyncRetryPolicy<TResult>(policyBuilder, (Func<DelegateResult<TResult>, TimeSpan, int, Context, Task>)((DelegateResult<TResult> exception, TimeSpan timespan, int i, Context ctx) => onRetryAsync(exception, i, timespan, ctx)), 2147483647, (IEnumerable<TimeSpan>)null, sleepDurationProvider);
}
}
}