8. Исключения в async¶

static async Task FailAsync()
{
    throw new InvalidOperationException("boom");   // до первого await
}

private void MoveNext()
{
    try
    {
        throw new InvalidOperationException("boom");
    }
    catch (Exception exception)
    {
        <>1__state = -2;
        <>t__builder.SetException(exception);
    }
}

internal static void SetException(Exception exception, ref Task<TResult> taskField)
{
    if (exception == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
    }
    Task<TResult> task = taskField ?? (taskField = new Task<TResult>());
    if (!((exception is OperationCanceledException ex) ? task.TrySetCanceled(ex.CancellationToken, ex) : task.TrySetException(exception)))
    {
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
    }
}

internal bool TrySetException(object exceptionObject)
{
    bool result = false;
    EnsureContingentPropertiesInitialized();
    if (AtomicStateUpdate(67108864, 90177536))
    {
        AddException(exceptionObject);
        Finish(userDelegateExecute: false);
        result = true;
    }
    return result;
}

internal void AddException(object exceptionObject, bool representsCancellation)
{
    ContingentProperties contingentProperties = EnsureContingentPropertiesInitialized();
    if (contingentProperties.m_exceptionsHolder == null)
    {
        TaskExceptionHolder taskExceptionHolder = new TaskExceptionHolder(this);
        if (Interlocked.CompareExchange(ref contingentProperties.m_exceptionsHolder, taskExceptionHolder, null) != null)
        {
            taskExceptionHolder.MarkAsHandled(calledFromFinalizer: false);
        }
    }
    lock (contingentProperties)
    {
        contingentProperties.m_exceptionsHolder.Add(exceptionObject, representsCancellation);
    }
}

internal sealed class TaskExceptionHolder
{
    private readonly Task m_task;
    private volatile List<ExceptionDispatchInfo> m_faultExceptions;
    private ExceptionDispatchInfo m_cancellationException;
    private volatile bool m_isHandled;

    ~TaskExceptionHolder()
    {
        if (m_faultExceptions != null && !m_isHandled)
        {
            UnobservedTaskExceptionEventArgs ueea = new UnobservedTaskExceptionEventArgs(new AggregateException(SR.TaskExceptionHolder_UnhandledException, m_faultExceptions));
            TaskScheduler.PublishUnobservedTaskException(m_task, ueea);
        }
    }

    private void AddFaultException(object exceptionObject)
    {
        List<ExceptionDispatchInfo> list = m_faultExceptions ?? (m_faultExceptions = new List<ExceptionDispatchInfo>(1));
        if (exceptionObject is Exception source)
        {
            list.Add(ExceptionDispatchInfo.Capture(source));
        }
        ...                                     // ExceptionDispatchInfo и коллекции — для WhenAll
        if (list.Count > 0)
        {
            MarkAsUnhandled();
        }
    }

    internal void MarkAsHandled(bool calledFromFinalizer)
    {
        if (!m_isHandled)
        {
            if (!calledFromFinalizer)
            {
                GC.SuppressFinalize(this);
            }
            m_isHandled = true;
        }
    }

    internal List<ExceptionDispatchInfo> GetExceptionDispatchInfos()
    {
        List<ExceptionDispatchInfo> faultExceptions = m_faultExceptions;
        MarkAsHandled(calledFromFinalizer: false);
        return faultExceptions;
    }
}

Console.WriteLine("== 1. Где живёт исключение ==");
Task t = FailAsync();
Console.WriteLine($"  вызов завершён, t.Status = {t.Status}");
Console.WriteLine($"  {Holder.Describe(t)}");
try { await t; }
catch (Exception e) { Console.WriteLine($"  поймано при await: {e.Message}"); }
Console.WriteLine($"  после await: {Holder.Describe(t)}");

static async Task SaveAsync(string name)
{
    if (name == null) throw new ArgumentNullException(nameof(name));   // уйдёт в Task!
    await Task.Delay(1);
}

var t = SaveAsync(null);       // не бросило; ошибка проявится позже, и только если кто-то дождётся задачи

static Task SaveAsync(string name)
{
    ArgumentNullException.ThrowIfNull(name);       // бросит сразу, синхронно
    return Core();

    async Task Core() { await Task.Delay(1); }
}

private static void ThrowForNonSuccess(Task task)
{
    switch (task.Status)
    {
    case TaskStatus.Canceled:
        task.GetCancellationExceptionDispatchInfo()?.Throw();
        throw new TaskCanceledException(task);
    case TaskStatus.Faulted:
    {
        List<ExceptionDispatchInfo> exceptionDispatchInfos = task.GetExceptionDispatchInfos();
        if (exceptionDispatchInfos.Count > 0)
        {
            exceptionDispatchInfos[0].Throw();
            break;
        }
        throw task.Exception;
    }
    }
}

internal TResult GetResultCore(bool waitCompletionNotification)
{
    if (!IsCompleted)
    {
        InternalWait(-1, default);
    }
    ...
    if (!IsCompletedSuccessfully)
    {
        ThrowIfExceptional(includeTaskCanceledExceptions: true);
    }
    return m_result;
}

internal void ThrowIfExceptional(bool includeTaskCanceledExceptions)
{
    Exception exceptions = GetExceptions(includeTaskCanceledExceptions);
    if (exceptions != null)
    {
        UpdateExceptionObservedStatus();
        throw exceptions;
    }
}

private AggregateException GetExceptions(bool includeTaskCanceledExceptions)
{
    ...
    if (ExceptionRecorded)
    {
        return m_contingentProperties.m_exceptionsHolder.CreateExceptionObject(calledFromFinalizer: false, ex);
    }
    ...
}

Console.WriteLine("== 3. await против .Result против GetAwaiter().GetResult() ==");
Task<int> deep = Level1Async();
try { await deep; } catch (Exception e) { Show("await", e); Console.WriteLine(Frames(e)); }
try { _ = deep.Result; } catch (Exception e) { Show(".Result", e); Console.WriteLine(Frames(e)); }
try { _ = deep.GetAwaiter().GetResult(); } catch (Exception e) { Show("GetAwaiter().GetResult()", e); }
Task<int> plain = Task.Run(Thrower);
try { _ = plain.GetAwaiter().GetResult(); } catch (Exception e) { Show("GetResult после обычного метода", e); Console.WriteLine(Frames(e)); }

// WhenAll(Task…)  — необобщённый
public void Invoke(Task completedTask)
{
    if (completedTask != null)
    {
        if (!completedTask.IsCompletedSuccessfully)
        {
            object obj = Interlocked.CompareExchange(ref m_stateObject, completedTask, null);
            if (obj != null)
            {
                ...                                   // второй и следующие: в List<Task>, в порядке ЗАВЕРШЕНИЯ
            }
        }
    }
    if (Interlocked.Decrement(ref _remainingToComplete) != 0)
    {
        return;
    }
    ...
    if (observedExceptions != null)
    {
        TrySetException(observedExceptions);
    }
    else if (canceledTask != null)
    {
        TrySetCanceled(canceledTask.CancellationToken, canceledTask.GetCancellationExceptionDispatchInfo());
    }
    ...
}

// WhenAll<T>(Task<T>…)  — обобщённый
for (int i = 0; i < m_tasks.Length; i++)
{
    Task<T> task2 = m_tasks[i];
    if (task2.IsFaulted)
    {
        list.AddRange(task2.GetExceptionDispatchInfos());     // в порядке ИНДЕКСОВ
    }
    ...
}

Console.WriteLine("== 4. WhenAll ==");
var slow = Task.Run(async () => { await Task.Delay(200); throw new InvalidOperationException("медленная, первая в списке"); });
var fast = Task.Run(async () => { await Task.Delay(50); throw new ArgumentException("быстрая, вторая в списке"); });
Task all = Task.WhenAll(slow, fast);
try { await all; }
catch (Exception e) { Console.WriteLine($"  await дал только: {e.GetType().Name}: {e.Message}"); }
foreach (var inner in all.Exception!.InnerExceptions)
    Console.WriteLine($"  в all.Exception: {inner.GetType().Name}: {inner.Message}");
var slowInt = Task.Run<int>(async () => { await Task.Delay(200); throw new InvalidOperationException("медленная, первая в списке"); });
var fastInt = Task.Run<int>(async () => { await Task.Delay(50); throw new ArgumentException("быстрая, вторая в списке"); });
Task<int[]> allInt = Task.WhenAll(slowInt, fastInt);
try { await allInt; }
catch (Exception e) { Console.WriteLine($"  Task<T>: await дал только: {e.GetType().Name}"); }
Console.WriteLine($"  Task<T>: порядок в all.Exception: {string.Join(", ", allInt.Exception!.InnerExceptions.Select(x => x.GetType().Name))}");
using (var cts = new CancellationTokenSource())
{
    cts.Cancel();
    Task canceled = Task.FromCanceled(cts.Token);
    Task mixed = Task.WhenAll(canceled, Task.FromException(new InvalidOperationException("упала")));
    try { await mixed; } catch (Exception) { }
    Console.WriteLine($"  WhenAll(отменённая, упавшая): Status = {mixed.Status}");
}

// AsyncVoidMethodBuilder.SetException
SynchronizationContext synchronizationContext = _synchronizationContext;
if (synchronizationContext != null)
{
    try
    {
        System.Threading.Tasks.Task.ThrowAsync(exception, synchronizationContext);
    }
    finally
    {
        NotifySynchronizationContextOfCompletion(synchronizationContext);
    }
}
else
{
    System.Threading.Tasks.Task.ThrowAsync(exception, null);
}

// Task.ThrowAsync
internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext)
{
    ExceptionDispatchInfo state = ExceptionDispatchInfo.Capture(exception);
    if (targetContext != null)
    {
        try
        {
            targetContext.Post((object obj) =>
            {
                ((ExceptionDispatchInfo)obj).Throw();
            }, state);
            return;
        }
        catch (Exception ex)
        {
            state = ExceptionDispatchInfo.Capture(new AggregateException(exception, ex));
        }
    }
    ThreadPool.QueueUserWorkItem((object obj) =>
    {
        ((ExceptionDispatchInfo)obj).Throw();
    }, state);
}

Console.WriteLine();
Console.WriteLine("== 5. async void ==");
Console.WriteLine("  в потоке есть контекст, который ловит Post: исключение приходит в него");
SynchronizationContext.SetSynchronizationContext(new CatchingContext());
FireAndForgetWithContext();
new List<int> { 1 }.ForEach(async x => { await Task.Yield(); throw new InvalidOperationException("из async-лямбды"); });
await Task.Delay(300);
SynchronizationContext.SetSynchronizationContext(null);
Console.WriteLine("  без контекста исключение роняет процесс: см. запуск с аргументами async-void и foreach-lambda");

Console.WriteLine();
Console.WriteLine("== 6. Невыясненные исключения ==");
var seen = new List<string>();
TaskScheduler.UnobservedTaskException += (_, e) => { seen.Add(e.Exception.InnerException!.Message); e.SetObserved(); };
DropFaultedTask("не прочитанная");
ReadThenDropFaultedTask("прочитанная через .Exception");
await Task.Delay(100);
for (int i = 0; i < 3; i++)
{
    GC.Collect();
    GC.WaitForPendingFinalizers();
}
Console.WriteLine($"  UnobservedTaskException сработал для: {(seen.Count == 0 ? "ничего" : string.Join(", ", seen))}");

private void HandleException(Exception unhandledException)
{
    if (unhandledException is OperationCanceledException ex && IsCancellationRequested && m_contingentProperties.m_cancellationToken == ex.CancellationToken)
    {
        SetCancellationAcknowledged();
        AddException(ex, representsCancellation: true);
    }
    else
    {
        AddException(unhandledException);
    }
}

Console.WriteLine("== 7. Исключение и отмена ==");
using var cancelled = new CancellationTokenSource();
cancelled.Cancel();
CancellationToken ct = cancelled.Token;
await Status("async-метод: throw new OperationCanceledException()", ThrowOceAsync(default));
await Status("async-метод: throw new OperationCanceledException(ct)", ThrowOceAsync(ct));
await Status("async-метод: throw new InvalidOperationException()", ThrowInvalidAsync());
await Status("Task.Run(Action): throw OCE() без токена", Task.Run((Action)(() => throw new OperationCanceledException())));
await Status("Task.Run(Action): throw OCE(ct), ct не передан в Run", Task.Run((Action)(() => throw new OperationCanceledException(ct))));
using var running = new CancellationTokenSource();
await Status("Task.Run(Action, tok): OCE(tok), токен отменён внутри", Task.Run((Action)(() => { running.Cancel(); throw new OperationCanceledException(running.Token); }), running.Token));
await Status("Task.Run(() => throw …): лямбда ушла в Func<Task>!", Task.Run(() => throw new OperationCanceledException()));
await Status("Task.Run(Action, ct): токен отменён до старта", Task.Run((Action)(() => { }), ct));