Continuación de tarea en subproceso de interfaz de usuario

¿Existe una forma 'estándar' de especificar que una continuación de la tarea debe ejecutarse en el hilo desde el que se creó la tarea inicial?

Actualmente tengo el siguiente código: funciona, pero hacer un seguimiento del despachador y crear una segunda acción parece una sobrecarga innecesaria.

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

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

Llame a la continuación con TaskScheduler.FromCurrentSynchronizationContext():

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

Esto es adecuado solo si el contexto de ejecución actual está en el hilo de la interfaz de usuario.

Con async solo haces:

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

Sin embargo:

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

Si tiene un valor de retorno que necesita enviar a la interfaz de usuario, puede usar la versión genérica como esta:

Esto se llama desde un MVVM ViewModel en mi caso.

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

Solo quería agregar esta versión porque es un hilo muy útil y creo que es una implementación muy simple. Lo he usado varias veces en varios tipos de aplicaciones multiproceso:

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

Llegué a través de google porque estaba buscando una buena manera de hacer cosas en el hilo de la interfaz de usuario después de estar dentro de una llamada de Task.Run: usando el siguiente código que puede usar awaitpara volver al hilo de la interfaz de usuario nuevamente.

Espero que esto ayude a alguien.

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