Quand utiliserais-je Task.Yield ()?

J'utilise async / wait et Taskbeaucoup mais je n'ai jamais utilisé Task.Yield()et pour être honnête, même avec toutes les explications, je ne comprends pas pourquoi j'aurais besoin de cette méthode.

Quelqu'un peut-il donner un bon exemple où cela Yield()est nécessaire?

Lorsque vous utilisez async/ await, il n'y a aucune garantie que la méthode que vous appelez lorsque vous le await FooAsync()ferez s'exécutera réellement de manière asynchrone. L'implémentation interne est libre de revenir en utilisant un chemin complètement synchrone.

Si vous créez une API où il est essentiel de ne pas bloquer et d'exécuter du code de manière asynchrone, et qu'il y a une chance que la méthode appelée s'exécute de manière synchrone (blocage efficace), l'utilisation await Task.Yield()force votre méthode à être asynchrone et retourne contrôle à ce point. Le reste du code s'exécutera ultérieurement (à ce moment, il peut toujours s'exécuter de manière synchrone) sur le contexte actuel.

Cela peut également être utile si vous créez une méthode asynchrone qui nécessite une initialisation «longue», c'est-à-dire:

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

Sans l' Task.Yield()appel, la méthode s'exécutera de manière synchrone jusqu'au premier appel à await.

En interne, met await Task.Yield()simplement la suite en file d'attente sur le contexte de synchronisation actuel ou sur un thread de pool aléatoire, si tel SynchronizationContext.Currentest le cas null.

Il est efficacement mis en œuvre comme serveur personnalisé. Un code moins efficace produisant l'effet identique pourrait être aussi simple que cela:

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()peut être utilisé comme raccourci pour certaines modifications de flux d'exécution étranges. Par exemple:

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  
}

Cela dit, je ne peux penser à aucun cas où Task.Yield()ne peut pas être remplacé par un Task.Factory.StartNewbon planificateur de tâches.

Voir également:

• "wait Task.Yield ()" et ses alternatives

• Task.Yield - usages réels?

Une utilisation de Task.Yield()est d'empêcher un débordement de pile lors de la récursion asynchrone. Task.Yield()empêche la poursuite syncrone. Notez cependant que cela peut provoquer une exception OutOfMemory (comme l'a noté Triynko). La récursion sans fin n'est toujours pas sûre et vous feriez probablement mieux de réécrire la récursivité en boucle.

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() peut être utilisé dans des implémentations simulées de méthodes asynchrones.