我有一系列任务,我正在等待Task.WhenAll
来完成。我的任务经常失败,在这种情况下,我会向用户显示一个消息框,以便她可以重试。我的问题是报告错误的时间延迟到所有任务完成为止。相反,我想在第一个任务抛出异常后立即通知用户。换句话说,我想要一个快速失败的Task.WhenAll
版本。由于不存在这样的内置方法,因此我尝试创建自己的方法,但是我的实现未达到我想要的方式。这是我想出的:
public static async Task<TResult[]> WhenAllFailFast<TResult>(
params Task<TResult>[] tasks)
{
foreach (var task in tasks)
{
await task.ConfigureAwait(false);
}
return await Task.WhenAll(tasks).ConfigureAwait(false);
}
这通常比本地Task.WhenAll
的抛出速度快,但通常不够快。在任务#1完成之前将不会观察到有故障的任务#2。我该如何改进它以使其尽快失效?
更新:关于取消,这不是我现在的要求,但是为了保持一致性,第一个被取消的任务应立即停止等待。在这种情况下,从WhenAllFailFast
返回的合并任务应具有Status == TaskStatus.Canceled
。
说明::取消方案是用户单击 Cancel 按钮以停止任务。这并不是要在发生异常时自动取消未完成的任务。
答案 0 :(得分:4)
您最好的选择是使用TaskCompletionSource
构建WhenAllFailFast
方法。您可以.ContinueWith()每个输入任务都具有同步延续,当任务以Faulted状态结束时(使用相同的异常对象),该同步延续会使TCS出错。
也许是这样的(未经过完全测试):
using System;
using System.Threading;
using System.Threading.Tasks;
namespace stackoverflow
{
class Program
{
static async Task Main(string[] args)
{
var cts = new CancellationTokenSource();
cts.Cancel();
var arr = await WhenAllFastFail(
Task.FromResult(42),
Task.Delay(2000).ContinueWith<int>(t => throw new Exception("ouch")),
Task.FromCanceled<int>(cts.Token));
Console.WriteLine("Hello World!");
}
public static Task<TResult[]> WhenAllFastFail<TResult>(params Task<TResult>[] tasks)
{
if (tasks is null || tasks.Length == 0) return Task.FromResult(Array.Empty<TResult>());
// defensive copy.
var defensive = tasks.Clone() as Task<TResult>[];
var tcs = new TaskCompletionSource<TResult[]>();
var remaining = defensive.Length;
Action<Task> check = t =>
{
switch (t.Status)
{
case TaskStatus.Faulted:
// we 'try' as some other task may beat us to the punch.
tcs.TrySetException(t.Exception.InnerException);
break;
case TaskStatus.Canceled:
// we 'try' as some other task may beat us to the punch.
tcs.TrySetCanceled();
break;
default:
// we can safely set here as no other task remains to run.
if (Interlocked.Decrement(ref remaining) == 0)
{
// get the results into an array.
var results = new TResult[defensive.Length];
for (var i = 0; i < tasks.Length; ++i) results[i] = defensive[i].Result;
tcs.SetResult(results);
}
break;
}
};
foreach (var task in defensive)
{
task.ContinueWith(check, default, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}
return tcs.Task;
}
}
}
编辑:展开AggregateException,取消支持,返回结果数组。防御数组突变,null和empty。明确的TaskScheduler。
答案 1 :(得分:3)
我最近再次需要使用WhenAllFailFast
方法,并且我修改了@ZaldronGG的excellent solution,使其性能更高(并且更加符合Stephen Cleary的建议)。下面的实现每秒在我的PC中处理大约3,500,000个任务。
public static Task<TResult[]> WhenAllFailFast<TResult>(params Task<TResult>[] tasks)
{
if (tasks is null) throw new ArgumentNullException(nameof(tasks));
if (tasks.Length == 0) return Task.FromResult(new TResult[0]);
var results = new TResult[tasks.Length];
var remaining = tasks.Length;
var tcs = new TaskCompletionSource<TResult[]>(
TaskCreationOptions.RunContinuationsAsynchronously);
for (int i = 0; i < tasks.Length; i++)
{
var task = tasks[i];
if (task == null) throw new ArgumentException(
$"The {nameof(tasks)} argument included a null value.", nameof(tasks));
HandleCompletion(task, i);
}
return tcs.Task;
async void HandleCompletion(Task<TResult> task, int index)
{
try
{
var result = await task.ConfigureAwait(false);
results[index] = result;
if (Interlocked.Decrement(ref remaining) == 0)
{
tcs.TrySetResult(results);
}
}
catch (OperationCanceledException)
{
tcs.TrySetCanceled();
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
}
答案 2 :(得分:2)
您的循环等待伪序列中的每个任务,因此这就是为什么它在检查task2是否失败之前等待task1完成。
您可能会发现本文对第一次失败后中止的模式很有帮助:http://gigi.nullneuron.net/gigilabs/patterns-for-asynchronous-composite-tasks-in-c/
public static async Task<TResult[]> WhenAllFailFast<TResult>(
params Task<TResult>[] tasks)
{
var taskList = tasks.ToList();
while (taskList.Count > 0)
{
var task = await Task.WhenAny(taskList).ConfigureAwait(false);
if(task.Exception != null)
{
// Left as an exercise for the reader:
// properly unwrap the AggregateException;
// handle the exception(s);
// cancel the other running tasks.
throw task.Exception.InnerException;
}
taskList.Remove(task);
}
return await Task.WhenAll(tasks).ConfigureAwait(false);
}