Wann würde ich Task.Yield () verwenden?

Ich benutze async / await und Taskviel, habe es aber nie benutzt Task.Yield()und um ehrlich zu sein, trotz all der Erklärungen verstehe ich nicht, warum ich diese Methode brauchen würde.

Kann jemand ein gutes Beispiel geben, wo Yield()es erforderlich ist?

Wenn Sie async/ verwenden await, gibt es keine Garantie dafür, dass die Methode, die Sie dabei aufrufen await FooAsync(), tatsächlich asynchron ausgeführt wird. Die interne Implementierung kann über einen vollständig synchronen Pfad zurückgegeben werden.

Wenn Sie eine API erstellen, bei der es wichtig ist, dass Sie nicht blockieren und Code asynchron ausführen, und die aufgerufene Methode await Task.Yield()möglicherweise synchron ausgeführt wird (effektiv blockiert), erzwingt die Verwendung, dass Ihre Methode asynchron ist, und kehrt zurück Kontrolle an diesem Punkt. Der Rest des Codes wird zu einem späteren Zeitpunkt (zu diesem Zeitpunkt wird er möglicherweise noch synchron ausgeführt) im aktuellen Kontext ausgeführt.

Dies kann auch nützlich sein, wenn Sie eine asynchrone Methode erstellen, die eine "lang laufende" Initialisierung erfordert, z.

 private async void button_Click(object sender, EventArgs e)
 {
      await Task.Yield(); // Make us async right away

      var data = ExecuteFooOnUIThread(); // This will run on the UI thread at some point later

      await UseDataAsync(data);
 }

Ohne den Task.Yield()Aufruf wird die Methode bis zum ersten Aufruf von synchron ausgeführt await.

Intern müssen Sie await Task.Yield()die Fortsetzung einfach entweder im aktuellen Synchronisationskontext oder in einem zufälligen Pool-Thread in die Warteschlange stellen, falls dies der Fall SynchronizationContext.Currentist null.

Es wird effizient als benutzerdefinierter Kellner implementiert. Ein weniger effizienter Code, der den identischen Effekt erzeugt, könnte so einfach sein:

var tcs = new TaskCompletionSource<bool>();
var sc = SynchronizationContext.Current;
if (sc != null)
    sc.Post(_ => tcs.SetResult(true), null);
else
    ThreadPool.QueueUserWorkItem(_ => tcs.SetResult(true));
await tcs.Task;

Task.Yield()kann als Abkürzung für einige seltsame Änderungen des Ausführungsflusses verwendet werden. Beispielsweise:

async Task DoDialogAsync()
{
    var dialog = new Form();

    Func<Task> showAsync = async () => 
    {
        await Task.Yield();
        dialog.ShowDialog();
    }

    var dialogTask = showAsync();
    await Task.Yield();

    // now we're on the dialog's nested message loop started by dialog.ShowDialog 
    MessageBox.Show("The dialog is visible, click OK to close");
    dialog.Close();

    await dialogTask;
    // we're back to the main message loop  
}

Das heißt, ich kann mir keinen Fall Task.Yield()vorstellen, in dem nicht durch einen Task.Factory.StartNewrichtigen Taskplaner ersetzt werden kann.

Siehe auch:

• "warte auf Task.Yield ()" und seine Alternativen

• Task.Yield - echte Verwendungen?

Eine Verwendung Task.Yield()besteht darin, einen Stapelüberlauf zu verhindern, wenn eine asynchrone Rekursion durchgeführt wird. Task.Yield()verhindert synchrone Fortsetzung. Beachten Sie jedoch, dass dies eine OutOfMemory-Ausnahme verursachen kann (wie von Triynko angegeben). Endlose Rekursion ist immer noch nicht sicher und Sie sollten die Rekursion wahrscheinlich besser als Schleife umschreiben.

private static void Main()
    {
        RecursiveMethod().Wait();
    }

    private static async Task RecursiveMethod()
    {
        await Task.Delay(1);
        //await Task.Yield(); // Uncomment this line to prevent stackoverlfow.
        await RecursiveMethod();
    }

Task.Yield() kann in Scheinimplementierungen von asynchronen Methoden verwendet werden.