Ошибка run task

У меня возникла проблема с перехватом исключения из Task.Run, которая была решена путем изменения кода следующим образом. Я хотел бы знать разницу между обработкой исключений двумя способами:

В методе Outside я не могу поймать исключение, но в методе Inside я могу.

void Outside()
{
    try
    {
        Task.Run(() =>
        {
            int z = 0;
            int x = 1 / z;
        });
    }
    catch (Exception exception)
    {
        MessageBox.Show("Outside : " + exception.Message);
    }
}

void Inside()
{
    Task.Run(() =>
    {
        try
        {
            int z = 0;
            int x = 1 / z;
        }
        catch (Exception exception)
        {
            MessageBox.Show("Inside : "+exception.Message);
        }
    });
}

Когда задача запускается, любые генерируемые ею исключения сохраняются и повторно генерируются, когда что-то ожидает результата задачи или завершения задачи.

Task.Run() возвращает объект Task, который вы можете использовать для этого, поэтому:

var task = Task.Run(...)

try
{
    task.Wait(); // Rethrows any exception(s).
    ...

Для более новых версий C # вы можете использовать await вместо Task.Wait ():

try
{
    await Task.Run(...);
    ...

Что намного аккуратнее.

Для полноты, вот компилируемое консольное приложение, демонстрирующее использование await:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main()
        {
            test().Wait();
        }

        static async Task test()
        {
            try
            {
                await Task.Run(() => throwsExceptionAfterOneSecond());
            }

            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

        static void throwsExceptionAfterOneSecond()
        {
            Thread.Sleep(1000); // Sleep is for illustration only. 
            throw new InvalidOperationException("Ooops");
        }
    }
}

Основываясь на ответе @MennoJongerius, следующее сохраняет асинхронность и перемещает исключение из .wait в обработчик событий Async Completed:

Public Event AsyncCompleted As AsyncCompletedEventHandler

).ContinueWith(Sub(t)
                   If t.IsFaulted Then
                       Dim evt As AsyncCompletedEventHandler = Me.AsyncCompletedEvent
                       evt?.Invoke(Me, New AsyncCompletedEventArgs(t.Exception, False, Nothing))
                   End If
               End Sub)

Для меня я хотел, чтобы мой Task.Run продолжался после ошибки, позволяя пользовательскому интерфейсу обрабатывать ошибку по мере необходимости.

Мое (странное?) Решение — запустить Form.Timer. В моем Task.Run есть очередь (для длительно выполняющихся материалов, не связанных с пользовательским интерфейсом), а у моего Form.Timer есть очередь (для элементов пользовательского интерфейса).

Поскольку этот метод уже работал у меня, было тривиально добавить обработку ошибок: если task.Run получает ошибку, он добавляет информацию об ошибке в очередь Form.Timer, которая отображает диалоговое окно ошибки.

Когда опция «Только мой код» включена, Visual Studio в некоторых случаях прерывает строку, которая вызывает исключение, и отображает сообщение об ошибке, в котором говорится:

Исключение не обрабатывается кодом пользователя.

Это доброкачественная ошибка. Вы можете нажать F5 , чтобы продолжить и увидеть поведение обработки исключений, продемонстрированное в этих примерах. Чтобы Visual Studio не сломалась при первой ошибке, просто снимите флажок «Только мой код» в разделе Инструменты> Параметры> Отладка> Общие .

Вы можете просто подождать, и тогда исключения всплывут в текущий контекст синхронизации (см. Ответ Мэтью Уотсона). Или, как упоминает Менно Йонгериус, вы можете ContinueWith, чтобы код оставался асинхронным. Обратите внимание, что вы можете сделать это, только если возникнет исключение с помощью параметра продолжения OnlyOnFaulted:

Task.Run(()=> {
    //.... some work....
})
// We could wait now, so we any exceptions are thrown, but that 
// would make the code synchronous. Instead, we continue only if 
// the task fails.
.ContinueWith(t => {
    // This is always true since we ContinueWith OnlyOnFaulted,
    // But we add the condition anyway so resharper doesn't bark.
    if (t.Exception != null)  throw t.Exception;
}, default
     , TaskContinuationOptions.OnlyOnFaulted
     , TaskScheduler.FromCurrentSynchronizationContext());

Во внешнем коде вы проверяете только, не вызывает ли запуск задачи исключение, а не тело задачи. Он выполняется асинхронно, и тогда выполняется код, который его инициировал.

Ты можешь использовать:

void Outside()
{
    try
    {
        Task.Run(() =>
        {
            int z = 0;
            int x = 1 / z;
        }).GetAwaiter().GetResult();
    }
    catch (Exception exception)
    {
        MessageBox.Show("Outside : " + exception.Message);
    }
}

Использование .GetAwaiter().GetResult() ожидает завершения задачи и передает выброшенное исключение как есть и не помещает их в AggregateException.

Идея использования Task.Wait сработает, но заставит вызывающий поток (как говорит код) ждать и, следовательно, блокировать, пока задача не будет завершена, что фактически делает код синхронным, а не асинхронным.

Вместо этого используйте параметр Task.ContinueWith для достижения результатов:

Task.Run(() =>
{
   //do some work
}).ContinueWith((t) =>
{
   if (t.IsFaulted) throw t.Exception;
   if (t.IsCompleted) //optionally do some work);
});

Если задача должна продолжаться в потоке пользовательского интерфейса, используйте параметр TaskScheduler.FromCurrentSynchronizationContext () в качестве параметра для продолжения следующим образом:

).ContinueWith((t) =>
{
    if (t.IsFaulted) throw t.Exception;
    if (t.IsCompleted) //optionally do some work);
}, TaskScheduler.FromCurrentSynchronizationContext());

Этот код просто повторно выбросит совокупное исключение с уровня задачи. Конечно, вы также можете ввести здесь другую форму обработки исключений.