Write an async helper that retries a transient operation a limited number of times and honors cancellation.

• Attempt count includes the first try.
• Do not retry when isTransient returns false.
• Do not swallow cancellation.
• Validate attempts and delay inputs.

I would use a for loop over attempts. Inside the loop, call the operation with the token. If it succeeds, return. If it throws and the exception is not transient, rethrow. If it is the last attempt, rethrow. Otherwise wait with Task.Delay(delay, cancellationToken). Passing the token into both the operation and delay is the key correctness point.

public static async Task<T> RetryAsync<T>(
    Func<CancellationToken, Task<T>> operation,
    Func<Exception, bool> isTransient,
    int maxAttempts,
    TimeSpan delay,
    CancellationToken cancellationToken)
{
    if (operation is null) throw new ArgumentNullException(nameof(operation));
    if (isTransient is null) throw new ArgumentNullException(nameof(isTransient));
    if (maxAttempts <= 0) throw new ArgumentOutOfRangeException(nameof(maxAttempts));
    if (delay < TimeSpan.Zero) throw new ArgumentOutOfRangeException(nameof(delay));

    for (var attempt = 1; ; attempt++)
    {
        cancellationToken.ThrowIfCancellationRequested();

        try
        {
            return await operation(cancellationToken);
        }
        catch (Exception exception) when (
            exception is not OperationCanceledException &&
            attempt < maxAttempts &&
            isTransient(exception))
        {
            if (delay > TimeSpan.Zero)
            {
                await Task.Delay(delay, cancellationToken);
            }
        }
    }
}

Time depends on operation cost and number of attempts. The helper itself uses O(1) space. Worst-case elapsed time includes operation duration plus delays between failed transient attempts.

• maxAttempts is 1.
• Non-transient exception on first attempt.
• Cancellation before the first attempt.
• Cancellation during delay.
• Operation throws OperationCanceledException.

• Use a fake operation that counts calls.
• Verify non-transient exceptions are not retried.
• Verify cancellation does not become a retryable failure.
• Verify delay is skipped after the final failed attempt.

• Catching all exceptions and retrying cancellation.
• Not passing the token to the operation or delay.
• Off-by-one attempt counts.
• Infinite retry loops.