使用带有条件延续的任务

Question

我对如何使用带有条件延续的任务感到有些困惑。

如果我有一个任务，然后我想继续处理成功和错误的任务，然后等待这些任务完成。

void FunctionThrows() {throw new Exception("faulted");}

static void MyTest()
{

    var taskThrows = Task.Factory.StartNew(() => FunctionThrows());

    var onSuccess = taskThrows.ContinueWith(
                          prev => Console.WriteLine("success"), 
                          TaskContinuationOptions.OnlyOnRanToCompleted);

    var onError = taskThrows.ContinueWith(
                          prev => Console.WriteLine(prev.Exception),
                          TaskContinuationOptions.OnlyOnFaulted);

    //so far, so good



    //this throws because onSuccess was cancelled before it was started
    Task.WaitAll(onSuccess, onError);
}

这是进行任务成功/失败分支的首选方式吗？另外，我应该如何加入所有这些任务，假设我创建了一长串延续，每个都有自己的错误处理。

  //for example
  var task1 = Task.Factory.StartNew(() => ...)
  var task1Error = task1.ContinueWith(  //on faulted
  var task2  = task1.ContinueWith(      //on success
  var task2Error = task2.ContinueWith(  //on faulted
  var task3 = task2.ContinueWith(       //on success
  //etc

在这些总是抛出调用WaitAll，因为某些延续将由于TaskContinuationOptions 而被取消，并且在取消的任务上调用Wait 抛出。 如何在不出现“任务已取消”异常的情况下加入这些？

Answer 1

我认为您的主要问题是您通过调用来告诉这两个任务“等待”

Task.WaitAll(onSuccess, onError);

onSuccess 和 onError 延续会自动为您设置，并将在其先前的任务完成后执行。

如果你只是用taskThrows.Start(); 替换你的Task.WaitAll(...)，我相信你会得到想要的输出。

这是我整理的一个例子：

class Program
{
    static int DivideBy(int divisor) 
    { 
      Thread.Sleep(2000);
      return 10 / divisor; 
    }

    static void Main(string[] args)
    {
        const int value = 0;

        var exceptionTask = new Task<int>(() => DivideBy(value));

        exceptionTask.ContinueWith(result => Console.WriteLine("Faulted ..."), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);
        exceptionTask.ContinueWith(result => Console.WriteLine("Success ..."), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);

        exceptionTask.Start();

        try
        {
            exceptionTask.Wait();
        }
        catch (AggregateException ex)
        {
            Console.WriteLine("Exception: {0}", ex.InnerException.Message);
        }

        Console.WriteLine("Press <Enter> to continue ...");
        Console.ReadLine();
    }
}

Answer 2

使用Task.WaitAny(onSuccess, onError);

Answer 3

这不正常吗？

查看 MSDN 文档，您做得很好，并且您实现的逻辑是合理的。您唯一缺少的是将 WaitAll 调用包装在 AggregateException 包装器中，如下所示：

// Exceptions thrown by tasks will be propagated to the main thread
// while it waits for the tasks. The actual exceptions will be wrapped in AggregateException.
try
{
    // Wait for all the tasks to finish.
    Task.WaitAll(tasks);

    // We should never get to this point
    Console.WriteLine("WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED.");
}
catch (AggregateException e)
{
    Console.WriteLine("\nThe following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)");
    for (int j = 0; j < e.InnerExceptions.Count; j++)
    {
        Console.WriteLine("\n-------------------------------------------------\n{0}", e.InnerExceptions[j].ToString());
    }
}

您可以在此处阅读更多内容： http://msdn.microsoft.com/en-us/library/dd270695.aspx

本质上，捕获 AggregatedException 与完成 WaitAll 相同。它是从您的任务返回的所有异常的集合。