如何从已取消的任务中获取内部异常

本文关键字：获取 内部 异常 任务 取消 | 更新日期: 2023-09-27 18:21:45

我有一个任务，在发生异常时，它会取消使用sme取消令牌的任务，并引发异常：

var cancellationTokenSource = new CancellationTokenSource();
var task1 = Task.Factory.StartNew(
                () =>
                    {
                        try
                        {
                            // Do work 
                        }
                        catch (Exception exception)
                        {                              
                            cancellationTokenSource.Cancel();
                            // rethrow the error
                            throw;
                        }     
                    },
                cancellationTokenSource.Token,
                TaskCreationOptions.None,
                taskScheduler);

我有另一个任务3（返回任务），它是任务1和任务2的延续，并使用相同的取消令牌：

return task3 =
                Task.Factory.ContinueWhenAll(
                    new[] { task1, task2 },
                    tasks =>
                        {                           
                           // Do work
                        },
                cancellationTokenSource.Token,
                TaskContinuationOptions.None,
                this.taskScheduler).Unwrap();

一旦任务1被取消，所有具有相同取消令牌的任务也将被取消。我需要得到task1抛出的内部异常，如何完成？

如何从已取消的任务中获取内部异常

使用异步/等待和常规异常处理怎么样？不过它需要.NET 4.5。类似这样的东西（我不知道任务之间必须如何交互，所以你的代码可能会看起来完全不同）：

using System;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            new MyClass().RunAsyncMethods();
            Console.ReadLine();
        }
        public class MyClass
        {
            public async void RunAsyncMethods()
            {
                try
                {
                    var cancellationTokenSource = new CancellationTokenSource();
                    var task1 = RunFirstTaskAsync(cancellationTokenSource);
                    var task2 = RunSecondTaskAsync(cancellationTokenSource);
                    await Task.WhenAll(task1, task2);
                    await RunThirdTaskAsync(cancellationTokenSource);
                    Console.WriteLine("Done");
                }
                catch (Exception exc)
                {
                    Console.WriteLine(exc.Message);
                }
            }
            public Task RunFirstTaskAsync(CancellationTokenSource cancelSource)
            {
                return Task.Run(() =>
                {
                    try
                    {
                        Console.WriteLine("First Task is Running");
                        throw new Exception("Error happened in first task");
                    }
                    catch (Exception exception)
                    {
                        cancelSource.Cancel();
                        throw;
                    }
                },
                    cancelSource.Token);
            }
            public Task RunSecondTaskAsync(CancellationTokenSource cancelSource)
            {
                return Task.Run(
                    () =>
                    {
                        Console.WriteLine("Second Task is Running");
                    },
                    cancelSource.Token);
            }
            public Task RunThirdTaskAsync(CancellationTokenSource cancelSource)
            {
                return Task.Run(
                    () =>
                    {
                        Console.WriteLine("Third Task is Running");
                    },
                    cancelSource.Token);
            }
        }
    }
}

更新：我更新了代码以使用WhenAll。

UPDATE：更新代码以使用Task.Run方法创建任务，而不是使用冷任务。

UPDATE：您可以省略async/await（尽管我认为这样更好），并进行一些老式的TPL错误处理。简单地说，不要对task3（返回任务）使用取消令牌，只对它正在等待的任务使用取消令牌。当它们完成时（正常或通过异常/取消），您可以在task3中处理异常，如下所示：

// don't use the cancellation token for the third task as you used for the previous ones
var task3 = Task.Factory.ContinueWhenAll(
                    new[] { task1, task2 },
                    tasks =>
                    {
                        if (tasks[0].Exception != null)
                        {
                            tasks[0].Exception.Handle(exc =>
                            {
                                Console.WriteLine("First task failed :(");
                                return false; // signal that exception was handled, so it won't propagate
                            });
                            // add additional code here, or inside the Handle method above
                        }
                        if (tasks[1].Exception != null)
                        {
                            tasks[1].Exception.Handle(exc =>
                            {
                                Console.WriteLine("Second task failed :(");
                                return false; // signal that exception was handled, so it won't propagate
                            });
                            // add additional code here, or inside the Handle method above
                        }
                        // do the same for the rest of the tasks or iterate throught them with a foreach loop...
                    });
相关文章：