Continuazione dell'attività sul thread dell'interfaccia utente

Esiste un modo "standard" per specificare che una continuazione dell'attività deve essere eseguita sul thread da cui è stata creata l'attività iniziale?

Attualmente ho il codice qui sotto: funziona, ma tenere traccia del dispatcher e creare una seconda azione sembra un sovraccarico inutile.

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

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

Chiama il seguito con TaskScheduler.FromCurrentSynchronizationContext():

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

Questo è adatto solo se il contesto di esecuzione corrente si trova sul thread dell'interfaccia utente.

Con async fai semplicemente:

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

Però:

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

Se hai un valore di ritorno che devi inviare all'interfaccia utente, puoi utilizzare la versione generica in questo modo:

Nel mio caso questo viene chiamato da 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());

Volevo solo aggiungere questa versione perché è un thread così utile e penso che sia un'implementazione molto semplice. L'ho usato più volte in vari tipi se l'applicazione multithread:

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

Sono arrivato qui tramite Google perché stavo cercando un buon modo per fare cose sul thread awaitdell'interfaccia utente dopo essere stato all'interno di una chiamata Task.Run: utilizzando il seguente codice è possibile utilizzare per tornare nuovamente al thread dell'interfaccia utente.

Spero che questo aiuti qualcuno.

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

Uso:

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