在任务异常的情况下，根据用户输入多次重试任务 [英] Retry a task multiple times based on user input in case of an exception in task
问题描述
我的应用程序中的所有服务调用都是作为任务实现的.当一个任务出现故障时，我需要向用户显示一个对话框来重试上次失败的操作.如果用户选择重试，程序应该重试任务,否则程序应该在记录异常后继续执行.有没有人对如何实现这个功能有一个高层次的想法?
All the service calls in my application are implemented as tasks.When ever a task is faulted ,I need to present the user with a dialog box to retry the last operation failed.If the user chooses retry the program should retry the task ,else the execution of the program should continue after logging the exception.Any one has got a high level idea on how to implement this functionality ?
推荐答案
UPDATE 5/2017
C# 6 异常过滤器使 catch 子句变得更加简单:
C# 6 exception filters make the catch clause a lot simpler :
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
while (true)
{
try
{
var result = await Task.Run(func);
return result;
}
catch when (retryCount-- > 0){}
}
}
和递归版本:
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
try
{
var result = await Task.Run(func);
return result;
}
catch when (retryCount-- > 0){}
return await Retry(func, retryCount);
}
原创
重试函数的编码方法有很多种:您可以使用递归或任务迭代.不久前，希腊 .NET 用户组中有一个讨论做到这一点的不同方法.
如果您使用的是 F#，您还可以使用 Async 结构.不幸的是，您至少不能在 Async CTP 中使用 async/await 构造，因为编译器生成的代码不喜欢在 catch 块中进行多次等待或可能的重新抛出.
There are many ways to code a Retry function: you can use recursion or task iteration. There was a discussion in the Greek .NET User group a while back on the different ways to do exactly this.
If you are using F# you can also use Async constructs. Unfortunately, you can't use the async/await constructs at least in the Async CTP, because the code generated by the compiler doesn't like multiple awaits or possible rethrows in catch blocks.
递归版本可能是在 C# 中构建 Retry 的最简单方法.以下版本不使用 Unwrap 并在重试前添加可选延迟:
The recursive version is perhaps the simplest way to build a Retry in C#. The following version doesn't use Unwrap and adds an optional delay before retries :
private static Task<T> Retry<T>(Func<T> func, int retryCount, int delay, TaskCompletionSource<T> tcs = null)
{
if (tcs == null)
tcs = new TaskCompletionSource<T>();
Task.Factory.StartNew(func).ContinueWith(_original =>
{
if (_original.IsFaulted)
{
if (retryCount == 0)
tcs.SetException(_original.Exception.InnerExceptions);
else
Task.Factory.StartNewDelayed(delay).ContinueWith(t =>
{
Retry(func, retryCount - 1, delay,tcs);
});
}
else
tcs.SetResult(_original.Result);
});
return tcs.Task;
}
StartNewDelayed 函数来自ParallelExtensionsExtras 示例并使用计时器来触发发生超时时的 TaskCompletionSource.
The StartNewDelayed function comes from the ParallelExtensionsExtras samples and uses a timer to trigger a TaskCompletionSource when the timeout occurs.
F# 版本要简单得多:
The F# version is a lot simpler:
let retry (asyncComputation : Async<'T>) (retryCount : int) : Async<'T> =
let rec retry' retryCount =
async {
try
let! result = asyncComputation
return result
with exn ->
if retryCount = 0 then
return raise exn
else
return! retry' (retryCount - 1)
}
retry' retryCount
不幸的是，不可能使用来自 Async CTP 的 async/await 在 C# 中编写类似的东西，因为编译器不喜欢 catch 块中的 await 语句.以下尝试也静默失败，因为运行时不喜欢在异常后遇到等待:
Unfortunatley, it isn't possible to write something similar in C# using async/await from the Async CTP because the compiler doesn't like await statements inside a catch block. The following attempt also fails silenty, because the runtime doesn't like encountering an await after an exception:
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
while (true)
{
try
{
var result = await TaskEx.Run(func);
return result;
}
catch
{
if (retryCount == 0)
throw;
retryCount--;
}
}
}
对于询问用户，可以修改Retry调用一个函数询问用户，并通过TaskCompletionSource返回一个任务，当用户回答时触发下一步，例如:
As for asking the user, you can modify Retry to call a function that asks the user and returns a task through a TaskCompletionSource to trigger the next step when the user answers, eg:
private static Task<bool> AskUser()
{
var tcs = new TaskCompletionSource<bool>();
Task.Factory.StartNew(() =>
{
Console.WriteLine(@"Error Occured, continue? YN");
var response = Console.ReadKey();
tcs.SetResult(response.KeyChar=='y');
});
return tcs.Task;
}
private static Task<T> RetryAsk<T>(Func<T> func, int retryCount, TaskCompletionSource<T> tcs = null)
{
if (tcs == null)
tcs = new TaskCompletionSource<T>();
Task.Factory.StartNew(func).ContinueWith(_original =>
{
if (_original.IsFaulted)
{
if (retryCount == 0)
tcs.SetException(_original.Exception.InnerExceptions);
else
AskUser().ContinueWith(t =>
{
if (t.Result)
RetryAsk(func, retryCount - 1, tcs);
});
}
else
tcs.SetResult(_original.Result);
});
return tcs.Task;
}
通过所有的延续，您可以看到为什么异步版本的 Retry 如此受欢迎.
With all the continuations, you can see why an async version of Retry is so desirable.
更新:
在 Visual Studio 2012 Beta 中，以下两个版本有效:
In Visual Studio 2012 Beta the following two versions work:
带有 while 循环的版本:
A version with a while loop:
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
while (true)
{
try
{
var result = await Task.Run(func);
return result;
}
catch
{
if (retryCount == 0)
throw;
retryCount--;
}
}
}
和递归版本:
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
try
{
var result = await Task.Run(func);
return result;
}
catch
{
if (retryCount == 0)
throw;
}
return await Retry(func, --retryCount);
}
这篇关于在任务异常的情况下，根据用户输入多次重试任务的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
