ConstantBackoffStrategy Class

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

Definition

A retry strategy that waits the same delay before every retry.
public sealed class ConstantBackoffStrategy : IRetryStrategy
Inheritance
Implements

Remarks

The ConstantBackoffStrategy class provides a retry mechanism with a constant wait time between retries. This strategy is useful for scenarios where a predictable retry pattern is desired, applying the same delay duration between each retry attempt without regard to the number of attempts made or the total elapsed time.

Constructors

ConstantBackoffStrategy(TimeSpan)

Initializes a new instance of the ConstantBackoffStrategy class with a specified delay duration between retry attempts.
public ConstantBackoffStrategy(TimeSpan delay)

Parameters

delay TimeSpan
The delay duration between retry attempts.

Exceptions

ArgumentOutOfRangeException
Thrown if delay is negative.

Properties

Delay

Gets the delay duration between retries.
public TimeSpan Delay { get; }

Property Value

TimeSpan
The delay duration between retries.

Methods

TryGetRetryDelay(TimeSpan, uint, out TimeSpan)

Returns the same delay for every retry attempt.
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. This parameter is ignored in this implementation.
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.