RunAsync - Comment puis-je attendre la fin des travaux sur le thread de l'INTERFACE utilisateur?

J'ai trouvé la suggestion suivante sur un Microsoft github: Comment attendent une INTERFACE utilisateur de la tâche envoyée à partir d'un thread d'arrière-plan.

Installation

Définir cette méthode d'extension pour le 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);
}

Une fois que vous avez tout ce que vous devez faire est d'utiliser le nouveau RunTaskAsync méthode pour avoir votre tâche de fond vous attendent sur l'INTERFACE de travail.

Exemple d'utilisation

Faisons semblant de croire que c'est la méthode qui doit s'exécuter dans le thread de l'INTERFACE utilisateur. Prêter attention aux instructions de débogage, ce qui aidera à suivre le flux:

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

À attendre de votre thread d'arrière-plan, c'est comment vous pouvez l'utiliser 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}.");
}

La sortie ressemble alors à ceci:

Object_Callback() a été appelé.

D'attente pour le choix de l'utilisateur...

Utilisateur a fait un choix. Retour résultat.

Object_Callback() s'exécute à nouveau. L'utilisateur a cliqué sur le Bouton 1.

OriginalL'auteur Mike

Vous pouvez encapsuler l'appel à RunAsync dans votre propre méthode asynchrone qui peut être attendu et de contrôle de l'achèvement de la tâche et donc la suite de l'attente des appelants vous-même.

Depuis asynchrone attendent est centrée sur le Task type, vous devez d'orchestrer le travail à l'aide de ce type. Cependant, généralement un Task horaires de lui-même pour s'exécuter sur un pool de threads thread et donc il ne peut pas être utilisé pour programmer l'INTERFACE utilisateur de travail.

Cependant, la TaskCompletionSource type a été inventé pour agir comme une sorte de marionnettiste à un imprévu Task. En d'autres termes, un TaskCompletionSource pouvez créer un mannequin Task qui n'est pas prévu de faire quoi que ce soit, mais par l'intermédiaire des méthodes sur la TaskCompletionSource semblent être en cours d'exécution et l'achèvement comme un travail normal.

Voir cet exemple.

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

Remarque: les principaux travaux en cours sur le thread d'INTERFACE utilisateur est juste quelques lignes dessinées sur l'écran de toutes les 100ms.

Un TaskCompletionSource est créé comme le puppet master. Regardez près de la fin et vous verrez qu'il a une Task propriété qui est retournée à l'appelant. De retour Task satisfait aux compilateurs besoins et rend la méthode awaitable et asynchrone.

Cependant, la Task est juste une marionnette, un proxy pour le travail en cours dans le thread de l'INTERFACE utilisateur.

Voir comment dans cette INTERFACE principale délégué-je utiliser le TaskCompletionSource.SetResult méthode pour forcer un résultat dans la Task (depuis retourné à l'appelant) et de communiquer que le travail est terminé.

Si il y a une erreur, j'utilise SetException à "tirer une autre chaîne de caractères" et de le faire apparaître comme une exception a barboter dans la marionnette Task.

Async-attendent sous-système sait pas différente, et il fonctionne comme vous le souhaitez.

Modifier

Comme demandé par le svick, si la méthode a été conçue pour être appelée uniquement à partir de la thread de l'INTERFACE utilisateur, alors cela devrait suffire:

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

OriginalL'auteur Luke Puplett