Fortsetzung der Aufgabe im UI-Thread

Gibt es eine "Standard" -Methode, um anzugeben, dass eine Aufgabenfortsetzung auf dem Thread ausgeführt werden soll, aus dem die ursprüngliche Aufgabe erstellt wurde?

Derzeit habe ich den folgenden Code - er funktioniert, aber den Dispatcher im Auge zu behalten und eine zweite Aktion zu erstellen, scheint unnötiger Aufwand zu sein.

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

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

Nennen Sie die Fortsetzung mit TaskScheduler.FromCurrentSynchronizationContext():

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

Dies ist nur geeignet, wenn sich der aktuelle Ausführungskontext im UI-Thread befindet.

Mit Async machen Sie einfach:

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

Jedoch:

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

Wenn Sie einen Rückgabewert haben, den Sie an die Benutzeroberfläche senden müssen, können Sie die generische Version wie folgt verwenden:

Dies wird in meinem Fall von einem MVVM ViewModel aufgerufen.

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

Ich wollte nur diese Version hinzufügen, weil dies ein so nützlicher Thread ist und ich denke, dass dies eine sehr einfache Implementierung ist. Ich habe dies mehrfach in verschiedenen Arten von Multithread-Anwendungen verwendet:

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

Ich bin über Google hierher gekommen, weil ich nach einer guten Möglichkeit gesucht habe, Dinge awaitim UI-Thread zu tun, nachdem ich mich in einem Task.Run-Aufruf befunden habe. Mit dem folgenden Code können Sie wieder zum UI-Thread zurückkehren.

Ich hoffe das hilft jemandem.

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

Verwendung:

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