偶尔我需要在放弃前重试某个操作几次。我的代码如下：
int retries = 3;
while(true) {
try {
DoSomething();
break; // success!
} catch {
if(--retries == 0) throw;
else Thread.Sleep(1000);
}
}
我想把这个重试函数改写成一个通用的重试函数：
TryThreeTimes(DoSomething);
在C#中是否可能？TryThreeTimes()方法的代码将是什么？
如果将简单重试相同调用的毯子捕获语句用作一般异常处理机制，可能会很危险。话虽如此，这里有一个基于lambda的重试包装器，您可以将其用于任何方法。我选择将重试次数和重试超时作为参数进行因素分解，以获得更多的灵活性：
public static class Retry
{
public static void Do(
Action action,
TimeSpan retryInterval,
int maxAttemptCount = 3)
{
Do<object>(() =>
{
action();
return null;
}, retryInterval, maxAttemptCount);
}
public static T Do<T>(
Func<T> action,
TimeSpan retryInterval,
int maxAttemptCount = 3)
{
var exceptions = new List<Exception>();
for (int attempted = 0; attempted < maxAttemptCount; attempted++)
{
try
{
if (attempted > 0)
{
Thread.Sleep(retryInterval);
}
return action();
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
throw new AggregateException(exceptions);
}
}
现在您可以使用此实用程序方法执行重试逻辑：
Retry.Do(() => SomeFunctionThatCanFail(), TimeSpan.FromSeconds(1));
或者：
Retry.Do(SomeFunctionThatCanFail, TimeSpan.FromSeconds(1));
或者：
int result = Retry.Do(SomeFunctionWhichReturnsInt, TimeSpan.FromSeconds(1), 4);
或者你甚至可以创建一个 async 重载。
Policy.Handle<DivideByZeroException>().WaitAndRetry(new[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3) }); - Todd Meinershagen你应该尝试Polly。它是由我编写的.NET库，使开发人员可以流畅地表达临时异常处理策略，如Retry、Retry Forever、Wait and Retry或Circuit Breaker。
Policy
.Handle<SqlException>(ex => ex.Number == 1205)
.Or<ArgumentException>(ex => ex.ParamName == "example")
.WaitAndRetry(3, _ => TimeSpan.FromSeconds(3))
.Execute(DoSomething);
public void TryThreeTimes(Action action)
{
var tries = 3;
while (true) {
try {
action();
break; // success!
} catch {
if (--tries == 0)
throw;
Thread.Sleep(1000);
}
}
}
然后您将调用：
TryThreeTimes(DoSomething);
...或者...
TryThreeTimes(() => DoSomethingElse(withLocalVariable));
public void DoWithRetry(Action action, TimeSpan sleepPeriod, int tryCount = 3)
{
if (tryCount <= 0)
throw new ArgumentOutOfRangeException(nameof(tryCount));
while (true) {
try {
action();
break; // success!
} catch {
if (--tryCount == 0)
throw;
Thread.Sleep(sleepPeriod);
}
}
}
用作：
DoWithRetry(DoSomething, TimeSpan.FromSeconds(2), tryCount: 10);
一个更现代化的版本，支持async/await：
public async Task DoWithRetryAsync(Func<Task> action, TimeSpan sleepPeriod, int tryCount = 3)
{
if (tryCount <= 0)
throw new ArgumentOutOfRangeException(nameof(tryCount));
while (true) {
try {
await action();
return; // success!
} catch {
if (--tryCount == 0)
throw;
await Task.Delay(sleepPeriod);
}
}
}
应该这样使用：
await DoWithRetryAsync(DoSomethingAsync, TimeSpan.FromSeconds(2), tryCount: 10);
--retryCount <= 0，因为如果您将其设置为0以禁用重试，它将永远继续。从技术上讲，“retryCount”这个术语并不是一个非常好的名称，因为如果将其设置为1，则不会重试。要么将其重命名为“tryCount”，要么在其后面加上“--”。 - StefanvdsThread.Sleep。替代方案是使用计时器，或者更可能的是现在使用 async 进行重试，使用 Task.Delay。 - Drew NoakesFunc<bool> - Kiquenet这可能是一个不好的想法。首先，它代表了“疯狂就是做同样的事情两次，并期待每次都有不同的结果”的格言。其次，这种编码模式本身不太适合组合。例如：
假设您的网络硬件层在失败时重新发送数据包三次，等待一秒钟后再重试。
现在假设软件层在数据包失败时三次重新发送关于失败的通知。
接着，假设通知层在通知交付失败时重新激活通知三次。
再假设错误报告层在通知失败时重新激活通知层三次。
然后，假设 Web 服务器在出现错误时重新激活错误报告三次。
最后，假设 Web 客户端在从服务器获取错误后重新发送请求三次。
现在假设路由通知到管理员的网络交换机上的线路已被拔掉。用户最终何时才能收到他们的错误消息？我的估计是大约需要十二分钟。
不要以为这只是一个愚蠢的例子：我们在客户代码中看到过此类 bug，尽管比我在这里描述的要严重得多。在特定的客户代码中，错误条件发生和最终向用户报告之间的时间差是几个星期，因为有许多层自动重试并等待。如果有十次重试而不是三次，想象一下会发生什么。
通常处理错误条件的正确方法是“立即报告并让用户决定如何处理”。如果用户想创建自动重试策略，在软件抽象的适当级别上创建该策略。
瞬态错误处理应用程序块提供了一组可扩展的重试策略，包括：
它还包括一组云服务的错误检测策略。
有关更多信息，请参见开发人员指南中的本章节。
可通过NuGet获得（搜索'topaz'）。
我是递归和扩展方法的粉丝，所以这是我的一点建议：
public static void InvokeWithRetries(this Action @this, ushort numberOfRetries)
{
try
{
@this();
}
catch
{
if (numberOfRetries == 0)
throw;
InvokeWithRetries(@this, --numberOfRetries);
}
}
允许功能和重试消息
public static T RetryMethod<T>(Func<T> method, int numRetries, int retryTimeout, Action onFailureAction)
{
Guard.IsNotNull(method, "method");
T retval = default(T);
do
{
try
{
retval = method();
return retval;
}
catch
{
onFailureAction();
if (numRetries <= 0) throw; // improved to avoid silent failure
Thread.Sleep(retryTimeout);
}
} while (numRetries-- > 0);
return retval;
}
您还可以考虑添加您想要重试的异常类型。例如，这是一个超时异常需要重试吗？还是一个数据库异常？
RetryForExcpetionType(DoSomething, typeof(TimeoutException), 5, 1000);
public static void RetryForExcpetionType(Action action, Type retryOnExceptionType, int numRetries, int retryTimeout)
{
if (action == null)
throw new ArgumentNullException("action");
if (retryOnExceptionType == null)
throw new ArgumentNullException("retryOnExceptionType");
while (true)
{
try
{
action();
return;
}
catch(Exception e)
{
if (--numRetries <= 0 || !retryOnExceptionType.IsAssignableFrom(e.GetType()))
throw;
if (retryTimeout > 0)
System.Threading.Thread.Sleep(retryTimeout);
}
}
}
我使用最新的方法实现了LBushkin的答案：
public static async Task Do(Func<Task> task, TimeSpan retryInterval, int maxAttemptCount = 3)
{
var exceptions = new List<Exception>();
for (int attempted = 0; attempted < maxAttemptCount; attempted++)
{
try
{
if (attempted > 0)
{
await Task.Delay(retryInterval);
}
await task();
return;
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
throw new AggregateException(exceptions);
}
public static async Task<T> Do<T>(Func<Task<T>> task, TimeSpan retryInterval, int maxAttemptCount = 3)
{
var exceptions = new List<Exception>();
for (int attempted = 0; attempted < maxAttemptCount; attempted++)
{
try
{
if (attempted > 0)
{
await Task.Delay(retryInterval);
}
return await task();
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
throw new AggregateException(exceptions);
}
并且使用它：
await Retry.Do([TaskFunction], retryInterval, retryAttempts);
函数[TaskFunction] 可以是 Task<T> 或者只是 Task。
使用Polly
https://github.com/App-vNext/Polly-Samples
这是我在Polly中使用的retry-generic。
public T Retry<T>(Func<T> action, int retryCount = 0)
{
PolicyResult<T> policyResult = Policy
.Handle<Exception>()
.Retry(retryCount)
.ExecuteAndCapture<T>(action);
if (policyResult.Outcome == OutcomeType.Failure)
{
throw policyResult.FinalException;
}
return policyResult.Result;
}
使用方法如下
var result = Retry(() => MyFunction()), 3);