RunAsync - 我如何等待 UI 线程上的工作完成？

Question

在等待Dispatcher.RunAsync 时，会在安排工作时发生延续，而不是在工作完成时。我怎样才能等待工作完成？

编辑

我最初的问题假设过早延续是由 API 的设计引起的，所以这是真正的问题。

当使用异步委托等待 Dispatcher.RunAsync 时，在委托代码中使用 await 时，会在遇到 await 时发生延续，而不是在工作完成时。我怎样才能等待工作完成？

编辑 2

您可能需要调度已经在 UI 线程上的工作的一个原因是要解决微妙的计时和布局问题。视觉树中元素的大小和位置值经常发生变化是很常见的，为 UI 的后续迭代安排工作会有所帮助。

Answer 1

我在Microsoft github repository 上找到了以下建议：如何await a UI task sent from a background thread。

设置

为CoreDispatcher定义这个扩展方法：

using System;
using System.Threading.Tasks;
using Windows.UI.Core;

public static class DispatcherTaskExtensions
{
    public static async Task<T> RunTaskAsync<T>(this CoreDispatcher dispatcher, 
        Func<Task<T>> func, CoreDispatcherPriority priority = CoreDispatcherPriority.Normal)
    {
        var taskCompletionSource = new TaskCompletionSource<T>();
        await dispatcher.RunAsync(priority, async () =>
        {
            try
            {
                taskCompletionSource.SetResult(await func());
            }
            catch (Exception ex)
            {
                taskCompletionSource.SetException(ex);
            }
        });
        return await taskCompletionSource.Task;
    }

    // There is no TaskCompletionSource<void> so we use a bool that we throw away.
    public static async Task RunTaskAsync(this CoreDispatcher dispatcher,
        Func<Task> func, CoreDispatcherPriority priority = CoreDispatcherPriority.Normal) => 
        await RunTaskAsync(dispatcher, async () => { await func(); return false; }, priority);
}

完成此操作后，您需要做的就是使用新的RunTaskAsync 方法让您的后台任务等待 UI 工作。

使用示例

让我们假设这是需要在 UI 线程中运行的方法。注意调试语句，这将有助于遵循流程：

public static async Task<string> ShowMessageAsync()
{
    // Set up a MessageDialog
    var popup = new Windows.UI.Popups.MessageDialog("Question", "Please pick a button to continue");
    popup.Commands.Add(new Windows.UI.Popups.UICommand("Button 1"));
    popup.Commands.Add(new Windows.UI.Popups.UICommand("Button 2"));
    popup.CancelCommandIndex = 0;

    // About to show the dialog
    Debug.WriteLine("Waiting for user choice...");
    var command = await popup.ShowAsync();

    // Dialog has been dismissed by the user
    Debug.WriteLine("User has made a choice. Returning result.");
    return command.Label;
}

要从您的后台线程等待它，您将使用RunTaskAsync：

// Background thread calls this method
public async void Object_Callback()
{
    Debug.WriteLine("Object_Callback() has been called.");

    // Do the UI work, and await for it to complete before continuing execution
    var buttonLabel = await Dispatcher.RunTaskAsync(ShowMessageAsync);
    
    Debug.WriteLine($"Object_Callback() is running again. User clicked {buttonLabel}.");
}

然后输出如下所示：

Object_Callback() 已被调用。

等待用户选择...

用户已做出选择。返回结果。

Object_Callback() 再次运行。用户点击了按钮 1。

Answer 2

您的问题是假设您想安排（并等待）工作在 UI 线程从 后台线程。

如果您将 UI 设为“主”，而后台线程设为“奴隶”。

因此，不是让后台线程await 为 UI 线程执行某些操作（使用笨拙且不可移植的Dispatcher.RunAsync），而是让 UI 线程await 为后台线程执行某些操作做（使用可移植的、为异步制作的Task.Run）。

Answer 3

您可以将对RunAsync 的调用包装在您自己的异步方法中，该方法可以等待并控制任务的完成，从而自己继续等待调用者。

由于 async-await 以 Task 类型为中心，因此您必须使用该类型来编排工作。但是，通常Task 将自己安排在线程池线程上运行，因此不能用于安排 UI 工作。

然而，TaskCompletionSource 类型的发明是为了充当不定期Task 的傀儡。换句话说，TaskCompletionSource 可以创建一个虚拟的Task，它没有计划做任何事情，但通过TaskCompletionSource 上的方法可以看起来像正常工作一样运行和完成。

看这个例子。

public Task PlayDemoAsync()
{
    var completionSource = new TaskCompletionSource<bool>();
    this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
    {
        try
        {
            foreach (var ppc in this.Plots.Select(p => this.TransformPlot(p, this.RenderSize)))
            {
                // For each subsequent stroke plot, we need to start a new figure.
                //
                if (this.Sketch.DrawingPoints.Any())
                    this.Sketch.StartNewFigure(ppc.First().Position);

                foreach (var point in ppc)
                {
                    await Task.Delay(100);

                    this.Sketch.DrawingPoints.Add(point.Position);
                }
            }

            completionSource.SetResult(true);
        }
        catch (Exception e)
        {
            completionSource.SetException(e);
        }
    });

    return (Task)completionSource.Task;
}

注意：UI 线程上的主要工作只是每 100 毫秒在屏幕上绘制一些线条。

TaskCompletionSource 被创建为 puppet master。查看接近尾声，您会看到它有一个Task 属性返回给调用者。返回Task 可以满足编译器的需求，并使方法可等待和异步。

但是，Task 只是一个傀儡，是 UI 线程中实际工作的代理。

看看我如何在主 UI 委托中使用 TaskCompletionSource.SetResult 方法将结果强制到 Task（因为返回给调用者）并传达工作已完成。

如果出现错误，我会使用 SetException 来“拉另一个字符串”，并让它看起来像是在 puppet Task 中冒出异常。

async-await 子系统没有什么不同，因此它可以按您的预期工作。

编辑

根据 svick 的提示，如果该方法设计为只能从 UI 线程调用，那么这就足够了：

    /// <summary>
    /// Begins a demonstration drawing of the asterism.
    /// </summary>
    public async Task PlayDemoAsync()
    {
        if (this.Sketch != null)
        {
            foreach (var ppc in this.Plots.Select(p => this.TransformPlot(p, this.RenderSize)))
            {
                // For each subsequent stroke plot, we need to start a new figure.
                //
                if (this.Sketch.DrawingPoints.Any())
                    this.Sketch.StartNewFigure(ppc.First().Position);

                foreach (var point in ppc)
                {
                    await Task.Delay(100);

                    this.Sketch.DrawingPoints.Add(point.Position);
                }
            }
        }
    }

Answer 4

即使您出于某种原因必须从工作线程开始，@StephenCleary 建议的干净方式工作的好方法是使用简单的辅助对象。使用下面的对象，您可以编写如下代码：

    await DispatchToUIThread.Awaiter;
    // Now you're running on the UI thread, so this code is safe:
    this.textBox.Text = text;

在您的 App.OnLaunched 中，您必须初始化对象：

    DispatchToUIThread.Initialize(rootFrame.Dispatcher);

您可以在await anything;找到以下代码背后的理论

public class DispatchToUIThread : INotifyCompletion
{
    private readonly CoreDispatcher dispatcher;

    public static DispatchToUIThread Awaiter { get; private set; }

    private DispatchToUIThread(CoreDispatcher dispatcher)
    {
        this.dispatcher = dispatcher;
    }

    [CLSCompliant(false)]
    public static void Initialize(CoreDispatcher dispatcher)
    {
        if (dispatcher == null) throw new ArgumentNullException("dispatcher");
        Awaiter = new DispatchToUIThread(dispatcher);
    }

    public DispatchToUIThread GetAwaiter()
    {
        return this;
    }

    public bool IsCompleted
    {
        get { return this.dispatcher.HasThreadAccess; }
    }

    public async void OnCompleted(Action continuation)
    {
        if (continuation == null) throw new ArgumentNullException("continuation");
        await this.dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => continuation());
    }

    public void GetResult() { }
}