¿Cuándo usaría Task.Yield ()?

Estoy usando async / await y Taskmucho, pero nunca he estado usando Task.Yield()y, para ser honesto, incluso con todas las explicaciones, no entiendo por qué necesitaría este método.

¿Alguien puede dar un buen ejemplo donde Yield()se requiere?

Cuando usa async/ await, no hay garantía de que el método al que llama cuando lo haga await FooAsync()realmente se ejecute de forma asincrónica. La implementación interna es libre de regresar utilizando una ruta completamente sincrónica.

Si está haciendo una API donde es crítico que no bloquee y ejecute algún código de forma asincrónica, y existe la posibilidad de que el método llamado se ejecute sincrónicamente (bloqueo efectivo), el uso await Task.Yield()obligará a su método a ser asíncrono y devolverá control en ese punto. El resto del código se ejecutará más adelante (en ese momento, aún puede ejecutarse sincrónicamente) en el contexto actual.

Esto también puede ser útil si realiza un método asincrónico que requiere una inicialización de "ejecución prolongada", es decir:

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

Sin la Task.Yield()llamada, el método se ejecutará sincrónicamente hasta la primera llamada a await.

Internamente, await Task.Yield()simplemente pone en cola la continuación en el contexto de sincronización actual o en un subproceso de grupo aleatorio, si SynchronizationContext.Currentes así null.

Se implementa eficientemente como camarero personalizado. Un código menos eficiente que produzca el mismo efecto podría ser tan simple como esto:

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()se puede usar como atajo para algunas alteraciones extrañas del flujo de ejecución. Por ejemplo:

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  
}

Dicho esto, no puedo pensar en ningún caso en el Task.Yield()que no se pueda reemplazar con Task.Factory.StartNewel programador de tareas adecuado.

Ver también:

• "aguardar Task.Yield ()" y sus alternativas

• Tarea.Rendimiento: ¿usos reales?

Un uso de Task.Yield()es evitar un desbordamiento de la pila al hacer una recursión asíncrona. Task.Yield()evita la continuación sincrónica. Sin embargo, tenga en cuenta que esto puede causar una excepción OutOfMemory (como lo señaló Triynko). La recursión sin fin todavía no es segura y probablemente sea mejor reescribir la recursión como un bucle.

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() puede usarse en implementaciones simuladas de métodos asincrónicos.