/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception and the current sleep duration. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider"/> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException"> /// timeSpanProvider /// or /// onRetry /// </exception> public static RetryPolicy WaitAndRetry(this PolicyBuilder policyBuilder, int retryCount, Func <int, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } var sleepDurations = Enumerable.Range(1, retryCount) .Select(sleepDurationProvider); return(new RetryPolicy( (action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleep(sleepDurations, onRetry) ), policyBuilder.ExceptionPredicates )); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the handled exception or result, current sleep duration, retry count, and context data. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider"/> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException"> /// timeSpanProvider /// or /// onRetry /// </exception> public static RetryPolicy <TResult> WaitAndRetry <TResult>(this PolicyBuilder <TResult> policyBuilder, int retryCount, Func <int, DelegateResult <TResult>, Context, TimeSpan> sleepDurationProvider, Action <DelegateResult <TResult>, TimeSpan, int, Context> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException(nameof(retryCount), "Value must be greater than or equal to zero."); } if (sleepDurationProvider == null) { throw new ArgumentNullException(nameof(sleepDurationProvider)); } if (onRetry == null) { throw new ArgumentNullException(nameof(onRetry)); } return(new RetryPolicy <TResult>( (action, context, cancellationToken) => RetryEngine.Implementation( action, context, cancellationToken, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryStateWaitAndRetryWithProvider <TResult>(retryCount, sleepDurationProvider, onRetry, context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception, current sleep duration and context data. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider"/> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException"> /// sleepDurationProvider /// or /// onRetry /// </exception> public static RetryPolicy WaitAndRetry(this PolicyBuilder policyBuilder, int retryCount, Func <int, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan, Context> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } var sleepDurations = Enumerable.Range(1, retryCount) .Select(sleepDurationProvider); return(new RetryPolicy((action, context, cancellationToken) => RetryEngine.Implementation( ct => { action(ct); return EmptyStruct.Instance; }, cancellationToken, policyBuilder.ExceptionPredicates, PredicateHelper <EmptyStruct> .EmptyResultPredicates, () => new RetryPolicyStateWithSleep <EmptyStruct>(sleepDurations, (outcome, timespan, ctx) => onRetry(outcome.Exception, timespan, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception, current sleep duration, retry count, and context data. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider"/> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException"> /// timeSpanProvider /// or /// onRetry /// </exception> public static RetryPolicy WaitAndRetry(this PolicyBuilder policyBuilder, int retryCount, Func <int, Exception, Context, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan, int, Context> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException(nameof(retryCount), "Value must be greater than or equal to zero."); } if (sleepDurationProvider == null) { throw new ArgumentNullException(nameof(sleepDurationProvider)); } if (onRetry == null) { throw new ArgumentNullException(nameof(onRetry)); } return(new RetryPolicy( (action, context, cancellationToken) => RetryEngine.Implementation( (ctx, ct) => { action(ctx, ct); return EmptyStruct.Instance; }, context, cancellationToken, policyBuilder.ExceptionPredicates, PredicateHelper <EmptyStruct> .EmptyResultPredicates, () => new RetryStateWaitAndRetryWithProvider <EmptyStruct>( retryCount, (i, outcome, ctx) => sleepDurationProvider(i, outcome.Exception, ctx), (outcome, timespan, i, ctx) => onRetry(outcome.Exception, timespan, i, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the handled exception or result and the current sleep duration. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider"/> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException"> /// sleepDurationProvider /// or /// onRetry /// </exception> public static RetryPolicy <TResult> WaitAndRetry <TResult>(this PolicyBuilder <TResult> policyBuilder, int retryCount, Func <int, TimeSpan> sleepDurationProvider, Action <DelegateResult <TResult>, TimeSpan> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } var sleepDurations = Enumerable.Range(1, retryCount) .Select(sleepDurationProvider); return(new RetryPolicy <TResult>( (action, context, cancellationToken) => RetryEngine.Implementation( action, cancellationToken, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryPolicyStateWithSleep <TResult>(sleepDurations, (outcome, span, ctx) => onRetry(outcome, span), context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates )); }
public void TestInitialize() { var serviceProvider = new ServiceCollection() .AddLogging() .AddLibraryDependencies() .BuildServiceProvider(); this.retryEngine = serviceProvider.GetRequiredService <RetryEngine>(); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy RetryForever(this PolicyBuilder policyBuilder, Action <Exception, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyState(onRetry, context) ), policyBuilder.ExceptionPredicates)); }
public FileDeleter( ProbeDbContext probeDbContext, RetryEngine retryEngine, IStorageProvider storageProvider, EventService eventService, AppsContainer appsContainer) { _probeDbContext = probeDbContext; _retryEngine = retryEngine; _storageProvider = storageProvider; _eventService = eventService; _appsContainer = appsContainer; }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy RetryForever(this PolicyBuilder policyBuilder, Action <Exception, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( () => { action(); return EmptyStruct.Instance; }, policyBuilder.ExceptionPredicates, Enumerable.Empty <ResultPredicate <EmptyStruct> >(), () => new RetryPolicyState <EmptyStruct>((outcome, ctx) => onRetry(outcome.Exception, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy RetryForever(this PolicyBuilder policyBuilder, Action <Exception, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context, cancellationToken) => RetryEngine.Implementation( ct => { action(ct); return EmptyStruct.Instance; }, cancellationToken, policyBuilder.ExceptionPredicates, PredicateHelper <EmptyStruct> .EmptyResultPredicates, () => new RetryPolicyState <EmptyStruct>((outcome, ctx) => onRetry(outcome.Exception, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and /// execution context. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurationProvider"></param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">sleepDurationProvider</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy WaitAndRetryForever(this PolicyBuilder policyBuilder, Func <int, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan, Context> onRetry) { if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleepDurationProvider(sleepDurationProvider, onRetry, context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception, retry count and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy Retry(this PolicyBuilder policyBuilder, int retryCount, Action <Exception, int, Context> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithCount(retryCount, onRetry, context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the handled exception or result and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy <TResult> RetryForever <TResult>(this PolicyBuilder <TResult> policyBuilder, Action <DelegateResult <TResult>, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy <TResult>( (action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryPolicyState <TResult>(onRetry, context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry as many times as there are provided <paramref name="sleepDurations"/> /// calling <paramref name="onRetry"/> on each retry with the raised exception, current sleep duration and context data. /// On each retry, the duration to wait is the current <paramref name="sleepDurations"/> item. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurations">The sleep durations to wait for on each retry.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException"> /// sleepDurations /// or /// onRetry /// </exception> public static RetryPolicy WaitAndRetry(this PolicyBuilder policyBuilder, IEnumerable <TimeSpan> sleepDurations, Action <Exception, TimeSpan, Context> onRetry) { if (sleepDurations == null) { throw new ArgumentNullException("sleepDurations"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleep(sleepDurations, onRetry, context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and /// execution context. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurationProvider"></param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">sleepDurationProvider</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy WaitAndRetryForever(this PolicyBuilder policyBuilder, Func <int, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan, Context> onRetry) { if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( () => { action(); return EmptyStruct.Instance; }, policyBuilder.ExceptionPredicates, Enumerable.Empty <ResultPredicate <EmptyStruct> >(), () => new RetryPolicyStateWithSleepDurationProvider <EmptyStruct>(sleepDurationProvider, (outcome, timespan, ctx) => onRetry(outcome.Exception, timespan, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception, retry count and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy Retry(this PolicyBuilder policyBuilder, int retryCount, Action <Exception, int, Context> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context) => RetryEngine.Implementation( () => { action(); return EmptyStruct.Instance; }, policyBuilder.ExceptionPredicates, Enumerable.Empty <ResultPredicate <EmptyStruct> >(), () => new RetryPolicyStateWithCount <EmptyStruct>(retryCount, (outcome, i, ctx) => onRetry(outcome.Exception, i, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the handled exception or result. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy <TResult> RetryForever <TResult>(this PolicyBuilder <TResult> policyBuilder, Action <Exception> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy <TResult>( (action, context, cancellationToken) => RetryEngine.Implementation( action, cancellationToken, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryPolicyState <TResult>((outcome, ctx) => onRetry(outcome.Exception), context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates )); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the handled exception or result, retry count and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy <TResult> RetryForever <TResult>(this PolicyBuilder <TResult> policyBuilder, Action <DelegateResult <TResult>, int, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException(nameof(onRetry)); } return(new RetryPolicy <TResult>( (action, context, cancellationToken) => RetryEngine.Implementation( action, context, cancellationToken, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryStateRetryForeverWithCount <TResult>(onRetry, context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry as many times as there are provided <paramref name="sleepDurations"/> /// calling <paramref name="onRetry"/> on each retry with the raised exception, current sleep duration, retry count and context data. /// On each retry, the duration to wait is the current <paramref name="sleepDurations"/> item. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurations">The sleep durations to wait for on each retry.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException"> /// sleepDurations /// or /// onRetry /// </exception> public static RetryPolicy WaitAndRetry(this PolicyBuilder policyBuilder, IEnumerable <TimeSpan> sleepDurations, Action <Exception, TimeSpan, int, Context> onRetry) { if (sleepDurations == null) { throw new ArgumentNullException("sleepDurations"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy( (action, context, cancellationToken) => RetryEngine.Implementation( ct => { action(ct); return EmptyStruct.Instance; }, cancellationToken, policyBuilder.ExceptionPredicates, PredicateHelper <EmptyStruct> .EmptyResultPredicates, () => new RetryPolicyStateWithSleep <EmptyStruct>(sleepDurations, (outcome, timespan, i, ctx) => onRetry(outcome.Exception, timespan, i, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry indefinitely until the action succeeds, /// calling <paramref name="onRetry"/> on each retry with the raised exception and /// execution context. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurationProvider">A function providing the duration to wait before retrying.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">sleepDurationProvider</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy WaitAndRetryForever(this PolicyBuilder policyBuilder, Func <int, Context, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan, Context> onRetry) { if (sleepDurationProvider == null) { throw new ArgumentNullException(nameof(sleepDurationProvider)); } if (onRetry == null) { throw new ArgumentNullException(nameof(onRetry)); } return(new RetryPolicy((action, context, cancellationToken) => RetryEngine.Implementation( (ctx, ct) => { action(ctx, ct); return EmptyStruct.Instance; }, context, cancellationToken, policyBuilder.ExceptionPredicates, PredicateHelper <EmptyStruct> .EmptyResultPredicates, () => new RetryStateWaitAndRetryForever <EmptyStruct>(sleepDurationProvider, (outcome, timespan, ctx) => onRetry(outcome.Exception, timespan, ctx), context) ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the handled exception or result, retry count and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy <TResult> Retry <TResult>(this PolicyBuilder <TResult> policyBuilder, int retryCount, Action <DelegateResult <TResult>, int, Context> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy <TResult>( (action, context, cancellationToken) => RetryEngine.Implementation( action, cancellationToken, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryPolicyStateWithCount <TResult>(retryCount, onRetry, context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the handled exception or result. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurationProvider"></param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">sleepDurationProvider</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy <TResult> WaitAndRetryForever <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(new RetryPolicy <TResult>( (action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryPolicyStateWithSleepDurationProvider <TResult>(sleepDurationProvider, onRetry) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates )); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry as many times as there are provided <paramref name="sleepDurations"/> /// calling <paramref name="onRetry"/> on each retry with the handled exception or result, current sleep duration, retry count and context data. /// On each retry, the duration to wait is the current <paramref name="sleepDurations"/> item. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurations">The sleep durations to wait for on each retry.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException"> /// sleepDurations /// or /// onRetry /// </exception> public static RetryPolicy <TResult> WaitAndRetry <TResult>(this PolicyBuilder <TResult> policyBuilder, IEnumerable <TimeSpan> sleepDurations, Action <DelegateResult <TResult>, TimeSpan, int, Context> onRetry) { if (sleepDurations == null) { throw new ArgumentNullException("sleepDurations"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy <TResult>( (action, context) => RetryEngine.Implementation( action, policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates, () => new RetryPolicyStateWithSleep <TResult>(sleepDurations, onRetry, context) ), policyBuilder.ExceptionPredicates, policyBuilder.ResultPredicates )); }
/// <summary> /// Builds a <see cref="Policy" /> that will wait and retry <paramref name="retryCount" /> times /// calling <paramref name="onRetryAsync" /> on each retry with the raised exception, the current sleep duration and context data. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider" /> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetryAsync">The action to call asynchronously on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException"> /// sleepDurationProvider /// or /// onRetryAsync /// </exception> public static RetryPolicy WaitAndRetryAsync(this PolicyBuilder policyBuilder, int retryCount, Func <int, TimeSpan> sleepDurationProvider, Func <Exception, TimeSpan, 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> sleepDurations = Enumerable.Range(1, retryCount) .Select(sleepDurationProvider); return(new RetryPolicy( (action, context, cancellationToken, continueOnCapturedContext) => RetryEngine.ImplementationAsync( action, cancellationToken, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleep(sleepDurations, onRetryAsync, context), continueOnCapturedContext), policyBuilder.ExceptionPredicates )); }
/// <summary> /// Builds a <see cref="Policy" /> that will retry indefinitely /// calling <paramref name="onRetry" /> on each retry with the raised exception. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy RetryForeverAsync(this PolicyBuilder policyBuilder, Action <Exception> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy( (action, context, cancellationToken, continueOnCapturedContext) => RetryEngine.ImplementationAsync( action, cancellationToken, policyBuilder.ExceptionPredicates, #pragma warning disable 1998 () => new RetryPolicyState(async e => onRetry(e)), #pragma warning restore 1998 continueOnCapturedContext), policyBuilder.ExceptionPredicates )); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and context data. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy RetryForeverAsync(this PolicyBuilder policyBuilder, Action <Exception, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy((action, context, cancellationToken, continueOnCapturedContext) => RetryEngine.ImplementationAsync( action, cancellationToken, policyBuilder.ExceptionPredicates, () => new RetryPolicyState(onRetry, context), continueOnCapturedContext ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry indefinitely /// calling <paramref name="onRetryAsync"/> on each retry with the raised exception and /// execution context. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurationProvider"></param> /// <param name="onRetryAsync">The action to call asynchronously on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">sleepDurationProvider</exception> /// <exception cref="System.ArgumentNullException">onRetryAsync</exception> public static RetryPolicy WaitAndRetryForeverAsync(this PolicyBuilder policyBuilder, Func <int, TimeSpan> sleepDurationProvider, Func <Exception, TimeSpan, Context, Task> onRetryAsync) { if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetryAsync == null) { throw new ArgumentNullException("onRetryAsync"); } return(new RetryPolicy( (action, context, cancellationToken, continueOnCapturedContext) => RetryEngine.ImplementationAsync( action, cancellationToken, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleepDurationProvider(sleepDurationProvider, onRetryAsync, context), continueOnCapturedContext ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and /// execution context. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurationProvider"></param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">sleepDurationProvider</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy WaitAndRetryForeverAsync(this PolicyBuilder policyBuilder, Func <int, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan, Context> onRetry) { if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy( (action, context, cancellationToken, continueOnCapturedContext) => RetryEngine.ImplementationAsync( action, cancellationToken, policyBuilder.ExceptionPredicates, #pragma warning disable 1998 () => new RetryPolicyStateWithSleepDurationProvider(sleepDurationProvider, async(e, t, c) => onRetry(e, t, c), context), #pragma warning restore 1998 continueOnCapturedContext ), policyBuilder.ExceptionPredicates)); }
/// <summary> /// Builds a <see cref="Policy" /> that will retry <paramref name="retryCount" /> times /// calling <paramref name="onRetry" /> on each retry with the raised exception and retry count. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than or equal to zero.</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static RetryPolicy RetryAsync(this PolicyBuilder policyBuilder, int retryCount, Action <Exception, int> onRetry) { if (retryCount < 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than or equal to zero."); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new RetryPolicy( (action, context, cancellationToken, continueOnCapturedContext) => RetryEngine.ImplementationAsync( action, cancellationToken, policyBuilder.ExceptionPredicates, #pragma warning disable 1998 () => new RetryPolicyStateWithCount(retryCount, async(e, i) => onRetry(e, i)), #pragma warning restore 1998 continueOnCapturedContext), policyBuilder.ExceptionPredicates )); }
public void Execute(Action action, CancellationToken cancellationToken) => RetryEngine.Execute(action, _maxTryCount, HandleException, cancellationToken);