IRetryStrategy Interface

Namespace

Assembly

Kampute.Resilience.dll

Definition

Defines a strategy for calculating the delay duration between retry attempts based on elapsed time and the number of retries already made.

public interface IRetryStrategy

Implemented by

Methods

TryGetRetryDelay(TimeSpan, uint, out TimeSpan)

Calculates the delay duration for the next retry attempt and indicates whether a retry should be attempted.

bool TryGetRetryDelay(TimeSpan elapsed, uint retryCount, out TimeSpan delay)

Parameters

elapsed TimeSpan: The total time elapsed since the start of retry attempts.
retryCount uint: The number of retries made so far, not counting the initial attempt.
delay TimeSpan: When this method returns, contains the calculated delay duration for the next retry attempt, if a retry is advisable. This parameter is passed uninitialized.

Returns

bool: true if a retry attempt is advisable and should be made after the calculated delay; false otherwise, indicating no further retry attempts should be made.

Extension Methods

Execute(this IRetryStrategy, Action<CancellationToken>, CancellationToken)	Runs a blocking operation and retries it as the strategy decides when it throws an exception.
Execute<T>(this IRetryStrategy, Func<CancellationToken, T>, CancellationToken)	Runs a blocking operation that returns a value and retries it as the strategy decides when it throws an exception.
Execute<TState>(this IRetryStrategy, TState, Action<TState, CancellationToken>, CancellationToken)	Runs a blocking operation that receives a state, and retries it as the strategy decides when it throws an exception.
Execute<TState, T>(this IRetryStrategy, TState, Func<TState, CancellationToken, T>, CancellationToken)	Runs a blocking operation that receives a state and returns a value, and retries it as the strategy decides when it throws an exception.
ExecuteAsync(this IRetryStrategy, Func<CancellationToken, Task>, CancellationToken)	Runs an asynchronous operation and retries it as the strategy decides when it throws an exception.
ExecuteAsync<T>(this IRetryStrategy, Func<CancellationToken, Task<T>>, CancellationToken)	Runs an asynchronous operation that returns a value and retries it as the strategy decides when it throws an exception.
ExecuteAsync<TState>(this IRetryStrategy, TState, Func<TState, CancellationToken, Task>, CancellationToken)	Runs an asynchronous operation that receives a state, and retries it as the strategy decides when it throws an exception.
ExecuteAsync<TState, T>(this IRetryStrategy, TState, Func<TState, CancellationToken, Task<T>>, CancellationToken)	Runs an asynchronous operation that receives a state and returns a value, and retries it as the strategy decides when it throws an exception.
OnRetry(this IRetryStrategy, Action<RetryContext>)	Creates a retry policy that retries every exception and invokes a handler for each approved retry.
OverrideDelay(this IRetryStrategy, Func<RetryContext, TimeSpan>)	Creates a retry policy that retries every exception, replacing the strategy's delay with one computed from the failed attempt.
RetryOn<TException>(this IRetryStrategy)	Creates a retry policy that retries the exceptions of the specified type as the strategy decides.
RetryOn(this IRetryStrategy, Func<Exception, bool>)	Creates a retry policy that retries the exceptions that satisfy a condition, as the strategy decides.
RetryOn<TException>(this IRetryStrategy, Func<TException, bool>)	Creates a retry policy that retries the exceptions of the specified type that satisfy a condition, as the strategy decides.
RetryOnResult<T>(this IRetryStrategy, Func<T, bool>)	Creates a retry policy for operations returning `T` that retries every exception and the results that satisfy a condition, as the strategy decides.
StartSession(this IRetryStrategy)	Starts a retry session for one operation that the strategy governs.
WithJitter(this IRetryStrategy, double)	Adds random jitter to the delays of a retry strategy.
WithMaxDelay(this IRetryStrategy, TimeSpan)	Caps each delay of a retry strategy.
WithMaxDelay(this IRetryStrategy, int)	Caps each delay of a retry strategy at a number of milliseconds.
WithMaxElapsedTime(this IRetryStrategy, TimeSpan)	Limits the time during which a retry strategy allows retries.
WithMaxElapsedTime(this IRetryStrategy, int)	Limits the time, in milliseconds, during which a retry strategy allows retries.
WithMaxRetries(this IRetryStrategy, uint)	Limits the number of retries a retry strategy allows.