Add Assert method to validate the result and retry

src/RetryCore/AsyncRetryTask.cs

@@ -125,6 +125,22 @@ public IAsyncRetriable OnFailureAsync(Func<RetryResult, int, Task> failureAction
 
  return this;
  }
+
+ /// <inheritdoc />
+ public IAsyncRetriable Assert(Func<RetryResult, bool> condition)
+ {
+ _retryTask = _retryTask.Assert(condition);
+
+ return this;
+ }
+
+ /// <inheritdoc />
+ public IAsyncRetriable Assert(Func<RetryResult, Task<bool>> condition)
+ {
+ _retryTask = _retryTask.Assert(condition);
+
+ return this;
+ }
 }
 
 /// <summary>
@@ -156,6 +172,10 @@ public AsyncRetryTask(Func<Task<T>> function, RetryOptions retryOptions, Type[]
 
  private readonly List<Delegate> _failureActions;
 
+ private Func<RetryResult<T>, bool>? _condition;
+
+ private Func<RetryResult<T>, Task<bool>>? _conditionTask;
+
  private CancellationToken _cancellationToken;
 
  /// <inheritdoc />
@@ -253,6 +273,24 @@ public IAsyncRetriable<T> OnFailureAsync(Func<RetryResult<T>, int, Task> failure
  return this;
  }
 
+ /// <inheritdoc />
+ public IAsyncRetriable<T> Assert(Func<RetryResult<T>, bool> condition)
+ {
+ _condition = condition;
+ _conditionTask = null;
+
+ return this;
+ }
+
+ /// <inheritdoc />
+ public IAsyncRetriable<T> Assert(Func<RetryResult<T>, Task<bool>> condition)
+ {
+ _conditionTask = condition;
+ _condition = null;
+
+ return this;
+ }
+
  private async Task<RetryResult<T>> TryImplAsync()
  {
  //TraceSource.TraceVerbose("Starting trying with max try time {0} and max try count {1}.",
@@ -307,6 +345,20 @@ private async Task<RetryResult<T>> TryImplAsync()
  break;
  }
 
+ //assert
+ try
+ {
+ if (await AssertThenRetry(result))
+ {
+ continue;
+ }
+ }
+ catch (Exception ex)
+ {
+ result.Exception = new AssertCallbackException(ex);
+ break;
+ }
+
  //onsuccess
  try
  {
@@ -351,6 +403,17 @@ private bool IsRetryException(Exception exception)
  return true;
  }
 
+ private async Task<bool> AssertThenRetry(RetryResult<T> result)
+ {
+ var stop = _condition?.Invoke(result) ?? true;
+ if (_conditionTask is not null)
+ {
+ stop = await _conditionTask(result);
+ }
+
+ return !stop;
+ }
+
  private bool ShouldContinue(RetryResult<T> result, TimeSpan triedTime, int triedCount)
  {
  if (triedTime >= _retryOptions.MaxTryTime)

src/RetryCore/Exceptions/AssertCallbackException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Retry.Exceptions
+{
+ public class AssertCallbackException : CallbackException
+ {
+ /// <inheritdoc />
+ public AssertCallbackException(Exception inner) : base(
+ "An exception occurs during Assert execution, see InnerException", inner)
+ {
+ }
+ }
+}

src/RetryCore/IAsyncRetriable.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -121,6 +121,24 @@ public Task<RetryResult> RunAsync(CancellationToken cancellationToken = default,
  /// <param name="failureAction">The action to take on failure.</param>
  /// <returns></returns>
  public IAsyncRetriable OnFailureAsync(Func<RetryResult, int, Task> failureAction);
+
+ /// <summary>
+ /// Retries the task until the specified condition return true, 
+ /// or the max try time/count is exceeded, or an exception is thrown druing task execution.
+ /// Then returns the value returned by the task.
+ /// </summary>
+ /// <param name = "condition">The assert condition.</param>
+ /// <returns></returns>
+ public IAsyncRetriable Assert(Func<RetryResult, bool> condition);
+
+ /// <summary>
+ /// Retries the task until the specified condition return true, 
+ /// or the max try time/count is exceeded, or an exception is thrown druing task execution.
+ /// Then returns the value returned by the task.
+ /// </summary>
+ /// <param name = "condition">The assert condition.</param>
+ /// <returns></returns>
+ public IAsyncRetriable Assert(Func<RetryResult, Task<bool>> condition);
 }
 
 public interface IAsyncRetriable<T>
@@ -247,5 +265,21 @@ public Task<RetryResult<T>> RunAsync(CancellationToken cancellationToken = defau
  /// <returns></returns>
  public IAsyncRetriable<T> OnFailureAsync(Func<RetryResult<T>, int, Task> failureAction);
 
- //public void RetryWhenResult();
+ /// <summary>
+ /// Retries the task until the specified condition return true, 
+ /// or the max try time/count is exceeded, or an exception is thrown druing task execution.
+ /// Then returns the value returned by the task.
+ /// </summary>
+ /// <param name = "condition">The assert condition.</param>
+ /// <returns></returns>
+ public IAsyncRetriable<T> Assert(Func<RetryResult<T>, bool> condition);
+
+ /// <summary>
+ /// Retries the task until the specified condition return true, 
+ /// or the max try time/count is exceeded, or an exception is thrown druing task execution.
+ /// Then returns the value returned by the task.
+ /// </summary>
+ /// <param name = "condition">The assert condition.</param>
+ /// <returns></returns>
+ public IAsyncRetriable<T> Assert(Func<RetryResult<T>, Task<bool>> condition);
 }

src/RetryCore/IRetriable.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace Retry;
 
@@ -67,6 +67,15 @@ public interface IRetriable
  /// <param name="failureAction">The action to take on failure.</param>
  /// <returns></returns>
  public IRetriable OnFailure(Action<RetryResult, int> failureAction);
+
+ /// <summary>
+ /// Retries the task until the specified condition return true, 
+ /// or the max try time/count is exceeded, or an exception is thrown druing task execution.
+ /// Then returns the value returned by the task.
+ /// </summary>
+ /// <param name = "condition">The assert condition.</param>
+ /// <returns></returns>
+ public IRetriable Assert(Func<RetryResult, bool> condition);
 }
 
 public interface IRetriable<T>
@@ -134,4 +143,13 @@ public interface IRetriable<T>
  /// <param name="failureAction">The action to take on failure.</param>
  /// <returns></returns>
  public IRetriable<T> OnFailure(Action<RetryResult<T>, int> failureAction);
+
+ /// <summary>
+ /// Retries the task until the specified condition return true, 
+ /// or the max try time/count is exceeded, or an exception is thrown druing task execution.
+ /// Then returns the value returned by the task.
+ /// </summary>
+ /// <param name = "condition">The assert condition.</param>
+ /// <returns></returns>
+ public IRetriable<T> Assert(Func<RetryResult<T>, bool> condition);
 }

src/RetryCore/RetryBuilder.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -33,40 +33,40 @@ public RetryBuilder()
  /// Builds this instance.
  /// </summary>
  /// <returns></returns>
- public IRetriable Build(Action tryTask)
+ public IRetriable Build(Action @try)
  {
- return new RetryTask(tryTask, GetOptions(), GetRetryExceptions());
+ return new RetryTask(@try, GetOptions(), GetRetryExceptions());
  }
 
  /// <summary>
  /// Builds the specified try task.
  /// </summary>
  /// <typeparam name="T"></typeparam>
- /// <param name="tryTask">The try task.</param>
+ /// <param name="try">The try task.</param>
  /// <returns></returns>
- public IRetriable<T> Build<T>(Func<T> tryTask)
+ public IRetriable<T> Build<T>(Func<T> @try)
  {
- return new RetryTask<T>(tryTask, GetOptions(), GetRetryExceptions());
+ return new RetryTask<T>(@try, GetOptions(), GetRetryExceptions());
  }
 
  /// <summary>
  /// Builds this instance.
  /// </summary>
  /// <returns></returns>
- public IAsyncRetriable Build(Func<Task> tryTask)
+ public IAsyncRetriable Build(Func<Task> @try)
  {
- return new AsyncRetryTask(tryTask, GetOptions(), GetRetryExceptions());
+ return new AsyncRetryTask(@try, GetOptions(), GetRetryExceptions());
  }
 
  /// <summary>
  /// Builds the specified try task.
  /// </summary>
  /// <typeparam name="T"></typeparam>
- /// <param name="tryTask">The try task.</param>
+ /// <param name="try">The try task.</param>
  /// <returns></returns>
- public IAsyncRetriable<T> Build<T>(Func<Task<T>> tryTask)
+ public IAsyncRetriable<T> Build<T>(Func<Task<T>> @try)
  {
- return new AsyncRetryTask<T>(tryTask, GetOptions(), GetRetryExceptions());
+ return new AsyncRetryTask<T>(@try, GetOptions(), GetRetryExceptions());
  }
 
  private Type[] GetRetryExceptions()

src/RetryCore/RetryCore.csproj

@@ -8,7 +8,7 @@
  <GenerateDocumentationFile>True</GenerateDocumentationFile>
  <LangVersion>latest</LangVersion>
 
- <Version>0.1.0</Version>
+ <Version>0.2.0</Version>
  <PackageId>$(AssemblyName)</PackageId>
  <Description>A library for retrying operations.</Description>
  <Authors>jerviscui</Authors>

src/RetryCore/RetryTask.cs

@@ -93,6 +93,14 @@ IRetriable IRetriable.OnFailure(Action<RetryResult, int> failureAction)
 
  return this;
  }
+
+ /// <inheritdoc />
+ public IRetriable Assert(Func<RetryResult, bool> condition)
+ {
+ _retryTask = _retryTask.Assert(condition);
+
+ return this;
+ }
 }
 
 /// <summary>
@@ -124,6 +132,8 @@ public RetryTask(Func<T> function, RetryOptions retryOptions, Type[] retryExcept
 
  private readonly List<Action<RetryResult<T>, int>> _failureActions;
 
+ private Func<RetryResult<T>, bool>? _condition;
+
  /// <inheritdoc />
  public IAsyncRetriable<T> AsAsync()
  {
@@ -178,6 +188,14 @@ public IRetriable<T> OnFailure(Action<RetryResult<T>, int> failureAction)
  return this;
  }
 
+ /// <inheritdoc />
+ public IRetriable<T> Assert(Func<RetryResult<T>, bool> condition)
+ {
+ _condition = condition;
+
+ return this;
+ }
+
  private RetryResult<T> TryImpl()
  {
  //TraceSource.TraceVerbose("Starting trying with max try time {0} and max try count {1}.",
@@ -232,6 +250,20 @@ private RetryResult<T> TryImpl()
  break;
  }
 
+ //assert
+ try
+ {
+ if (AssertThenRetry(result))
+ {
+ continue;
+ }
+ }
+ catch (Exception ex)
+ {
+ result.Exception = new AssertCallbackException(ex);
+ break;
+ }
+
  //onsuccess
  try
  {
@@ -276,6 +308,13 @@ private bool IsRetryException(Exception exception)
  return true;
  }
 
+ private bool AssertThenRetry(RetryResult<T> result)
+ {
+ var stop = _condition?.Invoke(result) ?? true;
+
+ return !stop;
+ }
+
  private bool ShouldContinue(RetryResult<T> result, TimeSpan triedTime, int triedCount)
  {
  if (triedTime >= _retryOptions.MaxTryTime)