Poursuite de la tâche sur le thread UI

Question

Existe-t-il un moyen "standard" de spécifier qu'une suite de tâche doit être exécutée sur le fil d'exécution à partir duquel la tâche initiale a été créée ?

Actuellement, j'ai le code ci-dessous - il fonctionne mais garder la trace du distributeur et créer une deuxième action semble être une surcharge inutile.

dispatcher = Dispatcher.CurrentDispatcher;
Task task = Task.Factory.StartNew(() =>
{
    DoLongRunningWork();
});

Task UITask= task.ContinueWith(() =>
{
    dispatcher.Invoke(new Action(() =>
    {
        this.TextBlock1.Text = "Complete"; 
    }
});

Answer 1

Appelez la suite avec TaskScheduler.FromCurrentSynchronizationContext() :

    Task UITask= task.ContinueWith(() =>
    {
     this.TextBlock1.Text = "Complete"; 
    }, TaskScheduler.FromCurrentSynchronizationContext());

Cela ne convient que si le contexte d'exécution actuel se trouve sur le thread de l'interface utilisateur.

Answer 2

Avec l'asynchronisme, il suffit de le faire :

await Task.Run(() => do some stuff);
// continue doing stuff on the same context as before.
// while it is the default it is nice to be explicit about it with:
await Task.Run(() => do some stuff).ConfigureAwait(true);

Cependant :

await Task.Run(() => do some stuff).ConfigureAwait(false);
// continue doing stuff on the same thread as the task finished on.

Answer 3

Si vous avez une valeur de retour que vous devez envoyer à l'interface utilisateur, vous pouvez utiliser la version générique comme ceci :

Dans mon cas, l'appel se fait à partir d'un ViewModel MVVM.

var updateManifest = Task<ShippingManifest>.Run(() =>
    {
        Thread.Sleep(5000);  // prove it's really working!

        // GenerateManifest calls service and returns 'ShippingManifest' object 
        return GenerateManifest();  
    })

    .ContinueWith(manifest =>
    {
        // MVVM property
        this.ShippingManifest = manifest.Result;

        // or if you are not using MVVM...
        // txtShippingManifest.Text = manifest.Result.ToString();    

        System.Diagnostics.Debug.WriteLine("UI manifest updated - " + DateTime.Now);

    }, TaskScheduler.FromCurrentSynchronizationContext());

Answer 4

Je voulais juste ajouter cette version parce que c'est un fil de discussion très utile et je pense que c'est une mise en œuvre très simple. Je l'ai utilisé plusieurs fois dans différents types d'applications multithread :

 Task.Factory.StartNew(() =>
      {
        DoLongRunningWork();
        Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
              { txt.Text = "Complete"; }));
      });

Answer 5

Je suis arrivé ici grâce à Google parce que je cherchais un bon moyen de faire des choses sur le thread de l'interface utilisateur après avoir été à l'intérieur d'un appel Task.Run - En utilisant le code suivant vous pouvez utiliser await pour revenir au fil conducteur de l'interface utilisateur.

J'espère que cela aidera quelqu'un.

public static class UI
{
    public static DispatcherAwaiter Thread => new DispatcherAwaiter();
}

public struct DispatcherAwaiter : INotifyCompletion
{
    public bool IsCompleted => Application.Current.Dispatcher.CheckAccess();

    public void OnCompleted(Action continuation) => Application.Current.Dispatcher.Invoke(continuation);

    public void GetResult() { }

    public DispatcherAwaiter GetAwaiter()
    {
        return this;
    }
}

Utilisation :

... code which is executed on the background thread...
await UI.Thread;
... code which will be run in the application dispatcher (ui thread) ...