public static async Task ImplementationAsync(Func <Task> action, IEnumerable <ExceptionPredicate> shouldRetryPredicates, Func <IRetryPolicyState> policyStateFactory) { IRetryPolicyState policyState = policyStateFactory(); while (true) { try { await action().NotOnCapturedContext(); return; } catch (Exception ex) { if (!shouldRetryPredicates.Any(predicate => predicate(ex))) { throw; } if (!policyState.CanRetry(ex)) { throw; } } } }
public static async Task ImplementationAsync(Func <Task> action, IEnumerable <ExceptionPredicate> shouldRetryPredicates, Func <IRetryPolicyState> policyStateFactory, bool continueOnCapturedContext) { IRetryPolicyState policyState = policyStateFactory(); while (true) { try { await action().ConfigureAwait(continueOnCapturedContext); return; } catch (Exception ex) { if (!shouldRetryPredicates.Any(predicate => predicate(ex))) { throw; } if (!(await policyState .CanRetryAsync(ex, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext))) { throw; } } } }
internal static async Task <TResult> ImplementationAsync <TResult>( Func <CancellationToken, Task <TResult> > action, CancellationToken cancellationToken, IEnumerable <ExceptionPredicate> shouldRetryExceptionPredicates, IEnumerable <ResultPredicate <TResult> > shouldRetryResultPredicates, Func <IRetryPolicyState <TResult> > policyStateFactory, bool continueOnCapturedContext) { IRetryPolicyState <TResult> policyState = policyStateFactory(); while (true) { cancellationToken.ThrowIfCancellationRequested(); try { DelegateResult <TResult> delegateOutcome = new DelegateResult <TResult>(await action(cancellationToken).ConfigureAwait(continueOnCapturedContext)); //cancellationToken.ThrowIfCancellationRequested(); if (!shouldRetryResultPredicates.Any(predicate => predicate(delegateOutcome.Result))) { return(delegateOutcome.Result); } //cancellationToken.ThrowIfCancellationRequested(); if (!await policyState .CanRetryAsync(delegateOutcome, cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext)) { return(delegateOutcome.Result); } } catch (Exception ex) { //if (cancellationToken.IsCancellationRequested) //{ // if (ex is OperationCanceledException && ((OperationCanceledException)ex).CancellationToken == cancellationToken) // { // throw; // } // cancellationToken.ThrowIfCancellationRequested(); //} if (!shouldRetryExceptionPredicates.Any(predicate => predicate(ex))) { throw; } if (!await policyState .CanRetryAsync(new DelegateResult <TResult>(ex), cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext)) { throw; } } } }
internal static async Task <TResult> ImplementationAsync <TResult>( Func <Context, CancellationToken, Task <TResult> > action, Context context, CancellationToken cancellationToken, IEnumerable <ExceptionPredicate> shouldRetryExceptionPredicates, IEnumerable <ResultPredicate <TResult> > shouldRetryResultPredicates, Func <IRetryPolicyState <TResult> > policyStateFactory, bool continueOnCapturedContext) { IRetryPolicyState <TResult> policyState = policyStateFactory(); while (true) { cancellationToken.ThrowIfCancellationRequested(); try { TResult result = await action(context, cancellationToken).ConfigureAwait(continueOnCapturedContext); if (!shouldRetryResultPredicates.Any(predicate => predicate(result))) { return(result); } if (!await policyState .CanRetryAsync(new DelegateResult <TResult>(result), cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext)) { return(result); } } catch (Exception ex) { Exception handledException = shouldRetryExceptionPredicates .Select(predicate => predicate(ex)) .FirstOrDefault(e => e != null); if (handledException == null) { throw; } if (!await policyState .CanRetryAsync(new DelegateResult <TResult>(handledException), cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext)) { if (handledException != ex) { ExceptionDispatchInfo.Capture(handledException).Throw(); } throw; } } } }
internal static async Task <TResult> ImplementationAsync <TResult>( Func <CancellationToken, Task <TResult> > action, CancellationToken cancellationToken, IEnumerable <ExceptionPredicate> shouldRetryExceptionPredicates, IEnumerable <ResultPredicate <TResult> > shouldRetryResultPredicates, Func <IRetryPolicyState <TResult> > policyStateFactory, bool continueOnCapturedContext) { IRetryPolicyState <TResult> policyState = policyStateFactory(); while (true) { cancellationToken.ThrowIfCancellationRequested(); try { TResult result = await action(cancellationToken).ConfigureAwait(continueOnCapturedContext); if (!shouldRetryResultPredicates.Any(predicate => predicate(result))) { return(result); } if (!await policyState .CanRetryAsync(new DelegateResult <TResult>(result), cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext)) { return(result); } } catch (Exception ex) { if (!shouldRetryExceptionPredicates.Any(predicate => predicate(ex))) { throw; } if (!await policyState .CanRetryAsync(new DelegateResult <TResult>(ex), cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext)) { throw; } } } }
internal static TResult Implementation <TResult>( Func <Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken, IEnumerable <ExceptionPredicate> shouldRetryExceptionPredicates, IEnumerable <ResultPredicate <TResult> > shouldRetryResultPredicates, Func <IRetryPolicyState <TResult> > policyStateFactory) { IRetryPolicyState <TResult> policyState = policyStateFactory(); while (true) { cancellationToken.ThrowIfCancellationRequested(); try { TResult result = action(context, cancellationToken); if (!shouldRetryResultPredicates.Any(predicate => predicate(result))) { return(result); } if (!policyState.CanRetry(new DelegateResult <TResult>(result), cancellationToken)) { return(result); } } catch (Exception ex) { if (!shouldRetryExceptionPredicates.Any(predicate => predicate(ex))) { throw; } if (!policyState.CanRetry(new DelegateResult <TResult>(ex), cancellationToken)) { throw; } } } }
public static async Task ImplementationAsync(Func <CancellationToken, Task> action, CancellationToken cancellationToken, IEnumerable <ExceptionPredicate> shouldRetryPredicates, Func <IRetryPolicyState> policyStateFactory, bool continueOnCapturedContext) { IRetryPolicyState policyState = policyStateFactory(); while (true) { cancellationToken.ThrowIfCancellationRequested(); try { await action(cancellationToken).ConfigureAwait(continueOnCapturedContext); return; } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) { if (ex is OperationCanceledException && ((OperationCanceledException)ex).CancellationToken == cancellationToken) { throw; } cancellationToken.ThrowIfCancellationRequested(); } if (!shouldRetryPredicates.Any(predicate => predicate(ex))) { throw; } if (!(await policyState .CanRetryAsync(ex, cancellationToken, continueOnCapturedContext) .ConfigureAwait(continueOnCapturedContext))) { throw; } } } }
internal static TResult Implementation <TResult>( Func <TResult> action, IEnumerable <ExceptionPredicate> shouldRetryExceptionPredicates, IEnumerable <ResultPredicate <TResult> > shouldRetryResultPredicates, Func <IRetryPolicyState <TResult> > policyStateFactory) { IRetryPolicyState <TResult> policyState = policyStateFactory(); while (true) { try { DelegateResult <TResult> delegateOutcome = new DelegateResult <TResult>(action()); if (!shouldRetryResultPredicates.Any(predicate => predicate(delegateOutcome.Result))) { return(delegateOutcome.Result); } if (!policyState.CanRetry(delegateOutcome)) { return(delegateOutcome.Result); } } catch (Exception ex) { if (!shouldRetryExceptionPredicates.Any(predicate => predicate(ex))) { throw; } if (!policyState.CanRetry(new DelegateResult <TResult>(ex))) { throw; } } } }