3. Awaiter и builder¶

awaiter = Task.Delay(100).GetAwaiter();                       // 1. получить awaiter
if (!awaiter.IsCompleted)                                     // 2. уже готово?
{
    num = (<>1__state = 0);                                   // 3. запомнить, где остановились
    <>u__1 = awaiter;                                         //    и awaiter
    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);   // 4. подписаться через builder
    return;                                                   // 5. уйти
}
// ... при возобновлении: awaiter = <>u__1; <>u__1 = default; <>1__state = -1;
awaiter.GetResult();                                          // 6. забрать результат или исключение

Console.WriteLine("== 1. Свой awaitable ==");
await TimeSpan.FromMilliseconds(300);
Console.WriteLine("  прошло 300 мс");

static class TimeSpanAwaitExtensions
{
    public static TaskAwaiter GetAwaiter(this TimeSpan delay) => Task.Delay(delay).GetAwaiter();
}

// Похоже устроен Task.Yield(): awaiter с IsCompleted == false, который ставит продолжение в очередь.
readonly struct Switch : INotifyCompletion
{
    public static Switch ToThreadPool() => default;
    public Switch GetAwaiter() => this;
    public bool IsCompleted => Thread.CurrentThread.IsThreadPoolThread;
    public void GetResult() { }
    public void OnCompleted(Action continuation) => ThreadPool.QueueUserWorkItem(_ => continuation());
}

Console.WriteLine($"  до Switch: на потоке пула: {Thread.CurrentThread.IsThreadPoolThread}");
await Switch.ToThreadPool();
Console.WriteLine($"  после Switch: на потоке пула: {Thread.CurrentThread.IsThreadPoolThread}");

public readonly struct TaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, ITaskAwaiter
{
    internal readonly Task m_task;

    public bool IsCompleted => m_task.IsCompleted;

    internal TaskAwaiter(Task task)
    {
        m_task = task;
    }

    public void OnCompleted(Action continuation)
    {
        OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true, flowExecutionContext: true);
    }

    public void UnsafeOnCompleted(Action continuation)
    {
        OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true, flowExecutionContext: false);
    }

    [StackTraceHidden]
    public void GetResult()
    {
        ValidateEnd(m_task);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    [StackTraceHidden]
    internal static void ValidateEnd(Task task, ConfigureAwaitOptions options = ConfigureAwaitOptions.None)
    {
        if (task.IsWaitNotificationEnabledOrNotRanToCompletion)
        {
            HandleNonSuccessAndDebuggerNotification(task, options);
        }
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    [StackTraceHidden]
    private static void HandleNonSuccessAndDebuggerNotification(Task task, ConfigureAwaitOptions options)
    {
        if (!task.IsCompleted)
        {
            task.InternalWait(-1, default);
        }
        task.NotifyDebuggerOfWaitCompletionIfNecessary();
        if (!task.IsCompletedSuccessfully)
        {
            if ((options & ConfigureAwaitOptions.SuppressThrowing) == 0)
            {
                ThrowForNonSuccess(task);
            }
            task.MarkExceptionsAsHandled();
        }
    }

    [StackTraceHidden]
    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 static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
    {
        ArgumentNullException.ThrowIfNull(continuation, "continuation");
        if (TplEventSource.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
        {
            continuation = OutputWaitEtwEvents(task, continuation);
        }
        task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext);
    }

    internal static void UnsafeOnCompletedInternal(Task task, IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
    {
        if (TplEventSource.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
        {
            task.SetContinuationForAwait(OutputWaitEtwEvents(task, stateMachineBox.MoveNextAction), continueOnCapturedContext, flowExecutionContext: false);
        }
        else
        {
            task.UnsafeSetContinuationForAwait(stateMachineBox, continueOnCapturedContext);
        }
    }
}

public struct LoggingBuilder<T>
{
    private AsyncTaskMethodBuilder<T> _inner;          // настоящая работа — у стандартного builder'а

    public static LoggingBuilder<T> Create()
    {
        Trace.Log("builder.Create()");
        return new LoggingBuilder<T> { _inner = AsyncTaskMethodBuilder<T>.Create() };
    }

    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
    {
        Trace.Log($"builder.Start() → MoveNext(), state машины = {State(stateMachine)}");
        _inner.Start(ref stateMachine);
        Trace.Log("builder.Start() вернулся в заглушку");
    }

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
    {
        Trace.Log($"builder.AwaitUnsafeOnCompleted({typeof(TAwaiter).Name}), state = {State(stateMachine)}");
        _inner.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
    }

[AsyncMethodBuilder(typeof(LoggingBuilder<>))]
static async Task<int> TracedAsync()
{
    Trace.Log("тело: до первого await");
    await Task.CompletedTask;                     // уже завершён: builder не понадобится
    Trace.Log("тело: после await Task.CompletedTask");
    await Task.Delay(100);                        // настоящая приостановка
    Trace.Log("тело: после await Task.Delay");
    return 42;
}

Trace.Log("вызываю TracedAsync()");
Task<int> traced = TracedAsync();
Trace.Log($"TracedAsync() вернул задачу, IsCompleted={traced.IsCompleted}");
Trace.Log($"await → {await traced}");

public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
    where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
{
    AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
}

internal static void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine,
    [NotNull] ref Task<TResult> taskField)
    where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
{
    IAsyncStateMachineBox stateMachineBox = GetStateMachineBox(ref stateMachine, ref taskField);
    AwaitUnsafeOnCompleted(ref awaiter, stateMachineBox);
}

internal static void AwaitUnsafeOnCompleted<TAwaiter>(ref TAwaiter awaiter, IAsyncStateMachineBox box)
    where TAwaiter : ICriticalNotifyCompletion
{
    TAwaiter val = default;
    if (val != null && awaiter is ITaskAwaiter)
    {
        TaskAwaiter.UnsafeOnCompletedInternal(Unsafe.As<TAwaiter, TaskAwaiter>(ref awaiter).m_task, box, continueOnCapturedContext: true);
        return;
    }
    val = default;
    if (val != null && awaiter is IConfiguredTaskAwaiter)
    {
        ref ConfiguredTaskAwaitable.ConfiguredTaskAwaiter reference = ref Unsafe.As<TAwaiter, ConfiguredTaskAwaitable.ConfiguredTaskAwaiter>(ref awaiter);
        TaskAwaiter.UnsafeOnCompletedInternal(reference.m_task, box, (reference.m_options & ConfigureAwaitOptions.ContinueOnCapturedContext) != 0);
        return;
    }
    val = default;
    if (val != null && awaiter is IStateMachineBoxAwareAwaiter)
    {
        try
        {
            ((IStateMachineBoxAwareAwaiter)(object)awaiter).AwaitUnsafeOnCompleted(box);
            return;
        }
        catch (Exception exception)
        {
            System.Threading.Tasks.Task.ThrowAsync(exception, null);
            return;
        }
    }
    try
    {
        Action moveNextAction = box.MoveNextAction;
        awaiter.UnsafeOnCompleted(moveNextAction);
    }
    catch (Exception exception2)
    {
        System.Threading.Tasks.Task.ThrowAsync(exception2, null);
    }
}

// А вот «безопасный» AwaitOnCompleted (для awaiter'ов только с INotifyCompletion), тело:
//     awaiter.OnCompleted(GetStateMachineBox(ref stateMachine, ref taskField).MoveNextAction);

public readonly struct YieldAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IStateMachineBoxAwareAwaiter
{
    public bool IsCompleted => false;

    void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
    {
        SynchronizationContext current = SynchronizationContext.Current;
        if (current != null && current.GetType() != typeof(SynchronizationContext))
        {
            current.Post((object s) => ((IAsyncStateMachineBox)s).MoveNext(), box);
            return;
        }
        TaskScheduler current2 = TaskScheduler.Current;
        if (current2 == TaskScheduler.Default)
        {
            ThreadPool.UnsafeQueueUserWorkItemInternal(box, preferLocal: false);
            return;
        }
        Task.Factory.StartNew((object s) => ((IAsyncStateMachineBox)s).MoveNext(), box, default,
            TaskCreationOptions.PreferFairness, current2);
    }

    public void GetResult()
    {
    }
}

    static void Measure(string title, Func<Task<int>, Task> call)
    {
        // У каждого вызова своя незавершённая задача: если подписать несколько вызовов на одну,
        // со второго подписчика задача заводит список продолжений, и его аллокация испортит замер.
        call(new TaskCompletionSource<int>().Task);          // прогрев: JIT и статические поля аллоцируют сами
        Task<int> pending = new TaskCompletionSource<int>().Task;
        long before = GC.GetAllocatedBytesForCurrentThread();
        Task task = call(pending);
        long bytes = GC.GetAllocatedBytesForCurrentThread() - before;
        Console.WriteLine($"  {title,-36}: {bytes,4} байт, {task.GetType().Name}");
    }

#pragma warning disable CS1998   // async без await: нарочно
    static async Task VoidSync() { }
    static async Task<int> IntSync(int value) => value;
#pragma warning restore CS1998

    static async Task<int> Suspend(Task<int> task) => await task;

    static async Task<long> FatSuspend(Task<int> task)
    {
        long a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8;   // все нужны после await → поля машины
        int r = await task;
        return a + b + c + d + e + f + g + h + r;
    }

public static Task<TResult> FromResult<TResult>(TResult result)
{
    if (result == null)
        return Task<TResult>.s_defaultResultTask;
    if (typeof(TResult) == typeof(bool))
        return (Task<TResult>)(object)(result ? TaskCache.s_trueTask : TaskCache.s_falseTask);
    if (typeof(TResult) == typeof(int))
    {
        int num = (int)(object)result;
        if ((uint)(num - -1) < 10u)
            return (Task<TResult>)(object)TaskCache.s_int32Tasks[num - -1];
    }
    else if (/* TResult — примитив без ссылок, и значение — нули */)
        return Task<TResult>.s_defaultResultTask;
    return new Task<TResult>(result);
}

internal static class TaskCache
{
    internal static readonly Task<int>[] s_int32Tasks = CreateInt32Tasks();   // 10 задач: от -1 до 8
    ...
}