Using AsyncMethodBuilder to force Task to start on thread pool

[murshex]

static async BackgroundTask ExampleFunc()
{
    // We are already on the thread pool
    await Task.Delay(1000);
    // Normally we would only be on the thread pool after first await
}

[AsyncMethodBuilder(typeof(BackgroundTaskMethodBuilder))]
public class BackgroundTask
{
    public TaskCompletionSource tcs = new();
    public TaskAwaiter GetAwaiter() => tcs.Task.GetAwaiter();
}

public class BackgroundTaskMethodBuilder
{
    public BackgroundTask Task { get; set; } = new();

    public static BackgroundTaskMethodBuilder Create() => new();

    public void Start<TStateMachine>(ref TStateMachine stateMachine)
        where TStateMachine : IAsyncStateMachine
        => ThreadPool.UnsafeQueueUserWorkItem(a => a(), stateMachine.MoveNext, true);

    public void AwaitOnCompleted<TAwaiter, TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine
        => awaiter.OnCompleted(stateMachine.MoveNext);

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion
        where TStateMachine : IAsyncStateMachine
        => awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
    
    public void SetStateMachine(IAsyncStateMachine stateMachine) {}
    public void SetResult() => Task.tcs.SetResult();
    public void SetException(Exception exception) => Task.tcs.SetException(exception);
}

Will I run into any problems using this?

Its pretty advanced but I was hoping I could find someone who understands...

Thanks

[murshex]

@stephentoub

[murshex]

Basically I'm trying to emulate Task.Yield() using AsyncMethodBuilder

[teo-tsirpanis]

Using await Task.Yield() in an async method that returns Task is more performant. Why don't you want to use it at the start of your method?

[murshex]

Using await Task.Yield() in an async method that returns Task is more performant. Why don't you want to use it at the start of your method?

I have a synchronizationcontext so I can’t use Task.Yield.

[stephentoub]

If that's your motivation for this, you can just add something like this to your project:

internal struct ThreadPoolAwaitable : ICriticalNotifyCompletion
{
    public ThreadPoolAwaitable GetAwaiter() => this;
    public bool IsCompleted => false;
    public void GetResult() { }
    public void OnCompleted(Action continuation) => UnsafeOnCompleted(continuation);
    public void UnsafeOnCompleted(Action continuation) => ThreadPool.UnsafeQueueUserWorkItem(state => ((Action)state)(), continuation);
}

and then do:

await default(ThreadPoolAwaitable);

instead of await Task.Yield();.