“await Task.Yield()”及其替代方案

Question

如果我需要将代码执行推迟到 UI 线程消息循环的未来迭代之后，我可以这样做：

await Task.Factory.StartNew(
    () => {
        MessageBox.Show("Hello!");
    },
    CancellationToken.None,
    TaskCreationOptions.None,
    TaskScheduler.FromCurrentSynchronizationContext());

这将类似于await Task.Yield(); MessageBox.Show("Hello!");，此外，如果我愿意，我可以选择取消任务。

在使用默认同步上下文的情况下，我可以类似地使用await Task.Run 在池线程上继续。

事实上，比起Task.Yield，我更喜欢Task.Factory.StartNew 和Task.Run，因为它们都明确定义了延续代码的范围。

那么，await Task.Yield() 在什么情况下真正有用？

Answer 1

考虑您希望异步任务返回值的情况。

现有同步方式：

public int DoSomething()
{
    return SomeMethodThatReturnsAnInt();
}

要进行异步，请添加 async 关键字并更改返回类型：

public async Task<int> DoSomething()

要使用Task.Factory.StartNew()，将方法的一行代码更改为：

// start new task
var task = Task<int>.Factory.StartNew(
    () => {
        return SomeMethodThatReturnsAnInt();
    },
    CancellationToken.None,
    TaskCreationOptions.None,
    TaskScheduler.FromCurrentSynchronizationContext() );

// await task, return control to calling method
await task;

// return task result
return task.Result;

对比如果您使用await Task.Yield()，则添加一行

// this returns control to the calling method
await Task.Yield();

// otherwise synchronous method scheduled for async execution by the 
// TaskScheduler of the calling thread
return SomeMethodThatReturnsAnInt();

后者更加简洁、易读，并且对现有的方法并没有太大的改变。

Answer 2

Task.Yield() 非常适合在 async 方法的其他同步部分“打孔”。

就我个人而言，我发现它在我有一个可以被多次调用的自我取消 async 方法（管理自己对应的 CancellationTokenSource 并在每次后续调用时取消先前创建的实例的方法）的情况下很有用在极短的时间内（即通过相互依赖的 UI 元素的事件处理程序）。在这种情况下，使用Task.Yield()，然后在CancellationTokenSource 被换出后立即检查IsCancellationRequested 可以防止执行可能代价高昂的工作，其结果无论如何都会被丢弃。

这是一个示例，其中只有对 SelfCancellingAsync 的最后排队调用才能执行昂贵的工作并运行到完成。

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

namespace TaskYieldExample
{
    class Program
    {
        private static CancellationTokenSource CancellationTokenSource;

        static void Main(string[] args)
        {
            SelfCancellingAsync();
            SelfCancellingAsync();
            SelfCancellingAsync();

            Console.ReadLine();
        }

        private static async void SelfCancellingAsync()
        {
            Console.WriteLine("SelfCancellingAsync starting.");

            var cts = new CancellationTokenSource();
            var oldCts = Interlocked.Exchange(ref CancellationTokenSource, cts);

            if (oldCts != null)
            {
                oldCts.Cancel();
            }

            // Allow quick cancellation.
            await Task.Yield();

            if (cts.IsCancellationRequested)
            {
                return;
            }

            // Do the "meaty" work.
            Console.WriteLine("Performing intensive work.");

            var answer = await Task
                .Delay(TimeSpan.FromSeconds(1))
                .ContinueWith(_ => 42, TaskContinuationOptions.ExecuteSynchronously);

            if (cts.IsCancellationRequested)
            {
                return;
            }

            // Do something with the result.
            Console.WriteLine("SelfCancellingAsync completed. Answer: {0}.", answer);
        }
    }
}

这里的目标是允许在对 async 方法的非等待调用返回后立即在同一 SynchronizationContext 上同步执行的代码（当它遇到第一个 await 时）更改影响执行的状态的异步方法。这与Task.Delay 实现的限制非常相似（我在这里谈论的是非零延迟期），但没有实际，可能会出现明显的延迟，这在某些情况下可能不受欢迎。

Answer 3

Task.Yield() 真正有用的一种情况是当您是await recursively-called synchronously-completed Tasks 时。因为 csharp 的 async/await “releases Zalgo” 通过尽可能同步运行延续，完全同步递归场景中的堆栈可以变得足够大，以至于您的进程死亡。我认为这也部分是由于 Task 间接调用无法支持尾调用。 await Task.Yield() 将延续安排为由调度程序而不是内联运行，从而避免堆栈增长并解决此问题。

另外，Task.Yield() 可用于缩短方法的同步部分。如果调用者需要在您的方法执行某些操作之前接收您的方法的Task，您可以使用Task.Yield() 强制返回Task，否则会自然发生。例如，在以下本地方法场景中，async 方法能够安全地获取对自己的 Task 的引用（假设您在单并发 SynchronizationContext 上运行它，例如在 winforms 中或通过 @987654323 @):

using Nito.AsyncEx;
using System;
using System.Threading.Tasks;

class Program
{
    // Use a single-threaded SynchronizationContext similar to winforms/WPF
    static void Main(string[] args) => AsyncContext.Run(() => RunAsync());

    static async Task RunAsync()
    {
        Task<Task> task = null;
        task = getOwnTaskAsync();
        var foundTask = await task;
        Console.WriteLine($"{task?.Id} == {foundTask?.Id}: {task == foundTask}");

        async Task<Task> getOwnTaskAsync()
        {
            // Cause this method to return and let the 「task」 local be assigned.
            await Task.Yield();
            return task;
        }
    }
}

输出：

3 == 3: True

很抱歉，我想不出任何现实生活中的场景，其中能够强制缩短 async 方法的同步部分是做某事的最佳方式。知道你可以像我刚刚展示的那样做一个技巧有时会很有用，但它也往往更危险。通常，您可以以更好、更易读和更线程安全的方式传递数据。例如，您可以使用 TaskCompletionSource 将本地方法的引用传递给它自己的 Task：

using System;
using System.Threading.Tasks;

class Program
{
    // Fully free-threaded! Works in more environments!
    static void Main(string[] args) => RunAsync().Wait();

    static async Task RunAsync()
    {
        var ownTaskSource = new TaskCompletionSource<Task>();
        var task = getOwnTaskAsync(ownTaskSource.Task);
        ownTaskSource.SetResult(task);
        var foundTask = await task;
        Console.WriteLine($"{task?.Id} == {foundTask?.Id}: {task == foundTask}");

        async Task<Task> getOwnTaskAsync(
            Task<Task> ownTaskTask)
        {
            // This might be clearer.
            return await ownTaskTask;
        }
    }
}

输出：

2 == 2: True

Answer 4

Task.Yield 不能替代Task.Factory.StartNew 或Task.Run。他们完全不同。当您awaitTask.Yield 时，您允许当前线程上的其他代码在不阻塞线程的情况下执行。可以把它想象成等待Task.Delay，除了Task.Yield 等到任务完成，而不是等待特定的时间。

注意：不要在 UI 线程上使用 Task.Yield 并假设 UI 将始终保持响应。并非总是如此。