RunAsync - Wie kann ich erwarten den Abschluss der Arbeit auf dem UI-thread?

Fand ich den folgenden Vorschlag über eine Microsoft github-repository: Wie warten auf einen UI-Aufgabe gesendet, die von einem hintergrund-thread.

Setup

Definieren diese Erweiterung-Methode für die 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);
}

Sobald Sie das tun, ist alles was Sie tun müssen, ist die neue RunTaskAsync Methode, um Ihre hintergrund-task warten, die auf der Benutzeroberfläche arbeiten.

Beispiel

Let ' s pretend, dass dies die Methode, die laufen muss in dem UI-thread. Achten Sie auf die debug-Anweisungen, die helfen, Folgen dem Fluss:

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;
}

Zu erwarten, dass von den hintergrund-thread ist dies, wie würden Sie 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}.");
}

Die Ausgabe sieht dann wie folgt aus:

Object_Callback() aufgerufen wurde.

Warten, für die Nutzer die Wahl...

Benutzer hat eine Wahl getroffen. Rücksendung Ergebnis.

Object_Callback() erneut ausgeführt wird. Benutzer geklickt die Schaltfläche 1.

Können Sie wickeln Sie den Aufruf RunAsync im eigenen asynchrone Methode kann abgewartet werden und die Kontrolle der Erledigung der Aufgabe und damit die Fortsetzung warten die Anrufer selbst.

Seit async-await, zentriert auf die Task geben, müssen Sie orchestrieren das arbeiten mit diesem Typ. Jedoch in der Regel einen Task Zeitpläne selbst laufen auf einem threadpool-thread und so kann es nicht verwendet werden, um Zeitplan-Benutzeroberfläche arbeiten.

Jedoch die TaskCompletionSource Art wurde erfunden, um fungieren als eine Art Puppenspieler zu einer ungeplanten Task. In anderen Worten, eine TaskCompletionSource können, erstellen Sie ein dummy - Task ist nicht geplant, etwas zu tun, aber über Methoden auf die TaskCompletionSource können angezeigt werden Ausführung und Vollendung, wie ein normaler job.

Diesem Beispiel sehen.

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;
}

Beachten: die wichtigste Arbeit auf dem UI-thread ist nur einige Linien gezogen, die auf dem Bildschirm alle 100ms.

Einen TaskCompletionSource erstellt, wie die puppet master. Suchen Sie in der Nähe des Ende und Sie werden sehen, dass es Task Eigenschaft, die an den Aufrufer zurückgegeben wird. Rückkehr Task erfüllt der Compiler braucht, und macht die Methode erwartbaren und asynchron.

Jedoch die Task ist nur eine Marionette, ein proxy für die tatsächliche Arbeit in den UI-thread.

Sehen, wie in der Haupt-UI-delegate-ich benutze die TaskCompletionSource.SetResult Methode, um Kraft, ein Ergebnis in der Task (da an den Aufrufer zurückgegeben) und zu kommunizieren, dass die Arbeit beendet ist.

Wenn es ein Fehler ist, ich benutze SetException zu 'ziehen Sie eine andere Zeichenfolge' und machen es scheinen, dass eine Ausnahme hat gequasselt-bis in die Puppe Task.

Den async-await-subsystem kennt es nicht anders und so funktioniert wie man es erwarten würde.

Bearbeiten

Als Aufforderung durch svick, wenn die Methode wurde entwickelt, aufrufbar sein, nur vom UI-thread, dann würde dies ausreichen:

    ///<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);
                }
            }
        }
    }