ExponentialBackoffStrategy Class

Namespace
Kampute.Resilience.Strategies
Assembly
  • Kampute.Resilience.dll

Definition

A retry strategy that exponentially increases the delay before each retry attempt.
public sealed class ExponentialBackoffStrategy : IRetryStrategy
Inheritance
  • object
  • ExponentialBackoffStrategy
Implements

Remarks

The ExponentialBackoffStrategy class calculates the delay between retry attempts by starting with an initial delay and then increasing it exponentially with each subsequent retry. It suits operations whose retries should become quickly less frequent while failures continue, giving the cause of the failure more time to clear before each further attempt.

Constructors

ExponentialBackoffStrategy(TimeSpan, double)

Initializes a new instance of the ExponentialBackoffStrategy class with a specified initial delay and multiplier.
public ExponentialBackoffStrategy(TimeSpan initialDelay, double multiplier)

Parameters

initialDelay TimeSpan
The initial delay duration before the first retry attempt.
multiplier double
The factor by which the delay is multiplied for each further retry.

Exceptions

ArgumentOutOfRangeException
Thrown if initialDelay is negative, or multiplier is less than 1 or is double.NaN.

Properties

InitialDelay

Gets the initial delay duration before the first retry attempt.
public TimeSpan InitialDelay { get; }

Property Value

TimeSpan
The initial delay duration before the first retry attempt.

Multiplier

Gets the factor by which the delay is multiplied for each further retry.
public double Multiplier { get; }

Property Value

double
The factor by which the delay is multiplied for each further retry. It is at least 1.

Methods

TryGetRetryDelay(TimeSpan, uint, out TimeSpan)

Calculates the delay for the next retry attempt, exponentially increasing based on the number of attempts made so far.
public bool TryGetRetryDelay(TimeSpan elapsed, uint retryCount, out TimeSpan delay)

Parameters

elapsed TimeSpan
The total time elapsed since the start of retry attempts. This parameter is ignored in this implementation.
retryCount uint
The number of retry attempts made so far.
delay TimeSpan
When this method returns, contains the calculated delay for the next retry attempt. This parameter is passed uninitialized.

Returns

bool
Always returns true, indicating that a retry attempt should be made after the calculated delay.

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.