c# - Cómo y cuándo usar `async` y` await`


Desde mi punto de vista, una de las cosas principales que se async y await es hacer que el código sea fácil de escribir y de leer, pero ¿está utilizándolo igual que para engendrar hilos de fondo para realizar una lógica de larga duración?

Actualmente estoy probando el ejemplo más básico. He agregado algunos comentarios en línea. ¿Puedes aclararlo por mí?

// I don't understand why this method must be marked as `async`.
private async void button1_Click(object sender, EventArgs e)
{
    Task<int> access = DoSomethingAsync();
    // task independent stuff here

    // this line is reached after the 5 seconds sleep from 
    // DoSomethingAsync() method. Shouldn't it be reached immediately? 
    int a = 1; 

    // from my understanding the waiting should be done here.
    int x = await access; 
}

async Task<int> DoSomethingAsync()
{
    // is this executed on a background thread?
    System.Threading.Thread.Sleep(5000);
    return 1;
}

Answers



Cuando se usa async y se await el compilador genera una máquina de estado en el fondo.

Aquí hay un ejemplo en el que espero poder explicar algunos de los detalles de alto nivel que están sucediendo:

public async Task MyMethodAsync()
{
    Task<int> longRunningTask = LongRunningOperationAsync();
    // independent work which doesn't need the result of LongRunningOperationAsync can be done here

    //and now we call await on the task 
    int result = await longRunningTask;
    //use the result 
    Console.WriteLine(result);
}

public async Task<int> LongRunningOperationAsync() // assume we return an int from this long running operation 
{
    await Task.Delay(1000); // 1 second delay
    return 1;
}

OK, entonces, ¿qué pasa aquí?

  1. Task<int> longRunningTask = LongRunningOperationAsync(); comienza a ejecutar LongRunningOperation

  2. El trabajo independiente se lleva a cabo supongamos que el hilo principal (ID del hilo = 1) y luego await longRunningTask sea ​​alcanzado.

    Ahora, si longRunningTask no ha finalizado y todavía se está ejecutando, MyMethodAsync() volverá a su método de llamada, por lo que el hilo principal no se bloquea. Cuando longRunningTask finaliza, un hilo del ThreadPool (puede ser cualquier hilo) volverá a MyMethodAsync() en su contexto anterior y continuará la ejecución (en este caso, imprimirá el resultado en la consola).

Un segundo caso sería que longRunningTask ya ha finalizado su ejecución y el resultado está disponible. Al llegar a la await longRunningTask ya tenemos el resultado, por lo que el código continuará ejecutándose en el mismo hilo. (en este caso, imprimir el resultado a la consola). Por supuesto, este no es el caso para el ejemplo anterior, donde hay un Task.Delay(1000) involucrado.




Además de las otras respuestas, eche un vistazo a await (C # Reference)

y más específicamente en el ejemplo incluido, explica su situación un poco

El siguiente ejemplo de Windows Forms ilustra el uso de await en un método asíncrono, WaitAsynchronouslyAsync. Contraste el comportamiento de ese método con el comportamiento de WaitSynchronously. Sin un operador aguardado aplicado a una tarea, WaitSynchronously se ejecuta sincrónicamente a pesar del uso del modificador asíncrono en su definición y una llamada a Thread.Sleep en su cuerpo.

private async void button1_Click(object sender, EventArgs e)
{
    // Call the method that runs asynchronously.
    string result = await WaitAsynchronouslyAsync();

    // Call the method that runs synchronously.
    //string result = await WaitSynchronously ();

    // Display the result.
    textBox1.Text += result;
}

// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window 
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
    await Task.Delay(10000);
    return "Finished";
}

// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
    // Add a using directive for System.Threading.
    Thread.Sleep(10000);
    return "Finished";
}



Desde mi punto de vista, una de las cosas principales que se sincronizan y aguardan es hacer que el código sea fácil de escribir y leer.

Deben hacer que el código asíncrono sea fácil de escribir y leer, sí.

¿Es lo mismo que engendrar hilos de fondo para realizar una lógica de larga duración?

De ningún modo.

// No entiendo por qué este método debe marcarse como "async".

La palabra clave async habilita la palabra clave await . Por lo tanto, cualquier método que use await debe marcarse como async .

// esta línea se alcanza después de los 5 segundos de suspensión del método DoSomethingAsync (). ¿No debería ser alcanzado inmediatamente?

No, porque los métodos async no se ejecutan en otro subproceso de manera predeterminada.

// ¿esto se ejecuta en un hilo de fondo?

No.

Puede encontrar útil mi introducción async / await . Los documentos oficiales de MSDN también son inusualmente buenos (especialmente la sección TAP ), y el equipo de async una excelente pregunta frecuente .




Mostrando las explicaciones anteriores en acción en un programa de consola simple -

class Program
{
    static void Main(string[] args)
    {
        TestAsyncAwaitMethods();
        Console.WriteLine("Press any key to exit...");
        Console.ReadLine();
    }

    public async static void TestAsyncAwaitMethods()
    {
        await LongRunningMethod();
    }

    public static async Task<int> LongRunningMethod()
    {
        Console.WriteLine("Starting Long Running method...");
        await Task.Delay(5000);
        Console.WriteLine("End Long Running method...");
        return 1;
    }
}

Y la salida es:

Starting Long Running method...
Press any key to exit...
End Long Running method...

Así,

  1. Principal inicia el método de larga ejecución a través de TestAsyncAwaitMethods. Eso vuelve inmediatamente sin detener el hilo actual e inmediatamente vemos el mensaje 'Presione cualquier tecla para salir'
  2. Mientras tanto, LongRunningMethod se ejecuta en segundo plano. Una vez que se completa, otro hilo de Threadpool toma este contexto y muestra el mensaje final

Por lo tanto, no hilo está bloqueado.




He luchado para encontrar ejemplos simples de lo que realmente hace async / await. Una vez que finalmente comencé a entender, creé este pequeño ejemplo simple que creo proporciona una muy buena idea general de lo que está pasando cuando se usa async / await en un nivel alto.

Nota: Task.Delay(1000) simplemente bloquea durante 1 segundo

Console.WriteLine(DateTime.Now);

// This block takes 1 second to run because all
// 5 tasks are running simultaneously
{
    var a = Task.Delay(1000);
    var b = Task.Delay(1000);
    var c = Task.Delay(1000);
    var d = Task.Delay(1000);
    var e = Task.Delay(1000);

    await a;
    await b;
    await c;
    await d;
    await e;
}

Console.WriteLine(DateTime.Now);

// This block takes 5 seconds to run because each "await"
// pauses the program until the task finishes
{
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
}
Console.WriteLine(DateTime.Now);

SALIDA:

5/24/2017 2:22:50 PM
5/24/2017 2:22:51 PM (First block took 1 second)
5/24/2017 2:22:56 PM (Second block took 5 seconds)



Creo que has elegido un mal ejemplo con System.Threading.Thread.Sleep

El punto de una tarea async es permitir que se ejecute en segundo plano sin bloquear el hilo principal, como hacer un DownloadFileAsync

System.Threading.Thread.Sleep no es algo que se "está haciendo", simplemente duerme y, por lo tanto, se llega a la siguiente línea después de 5 segundos ...

Lee este artículo, creo que es una gran explicación de async y await concepto: http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx




Aquí hay un programa de consola rápido para dejar en claro a los que siguen. El método "TaskToDo" es su método de larga ejecución que desea sincronizar. Hacer que funcione Async se realiza mediante el método TestAsync. El método de bucles de prueba solo ejecuta las tareas de "Tarea para hacer" y las ejecuta Async. Puede ver eso en los resultados porque no se completan en el mismo orden desde la ejecución hasta la ejecución; informan al hilo de la interfaz de usuario de la consola cuando se completan. Simplista, pero creo que los ejemplos simplistas resaltan el núcleo del patrón mejor que los ejemplos más involucrados:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace TestingAsync
{
    class Program
    {
        static void Main(string[] args)
        {
            TestLoops();
            Console.Read();
        }

        private static async void TestLoops()
        {
            for (int i = 0; i < 100; i++)
            {
                await TestAsync(i);
            }
        }

        private static Task TestAsync(int i)
        {
            return Task.Run(() => TaskToDo(i));
        }

        private async static void TaskToDo(int i)
        {
            await Task.Delay(10);
            Console.WriteLine(i);
        }
    }
}



Esta respuesta tiene como objetivo proporcionar información específica para ASP.NET.

Al utilizar async / await en el controlador MVC, es posible aumentar la utilización del grupo de subprocesos y lograr un rendimiento mucho mejor, como se explica en el siguiente artículo,

http://www.asp.net/mvc/tutorials/mvc-4/using-asynchronous-methods-in-aspnet-mvc-4

En aplicaciones web que ven una gran cantidad de solicitudes simultáneas al inicio o tienen una carga de ráfagas (donde la concurrencia aumenta repentinamente), hacer que estas llamadas al servicio web sean asíncronas aumentará la capacidad de respuesta de su aplicación. Una solicitud asincrónica requiere la misma cantidad de tiempo para procesar que una solicitud síncrona. Por ejemplo, si una solicitud realiza una llamada de servicio web que requiere dos segundos para completarse, la solicitud demora dos segundos, ya sea que se realice de forma síncrona o asíncrona. Sin embargo, durante una llamada asincrónica, un hilo no está bloqueado para responder a otras solicitudes mientras espera a que se complete la primera solicitud. Por lo tanto, las solicitudes asincrónicas evitan que las colas de solicitudes crezcan y el grupo de subidas crezca cuando hay muchas solicitudes concurrentes que invocan operaciones de larga ejecución.




Para ser sincero, sigo pensando que la mejor explicación es la del futuro y las promesas en la Wikipedia: http://en.wikipedia.org/wiki/Futures_and_promises

La idea básica es que tienes un conjunto separado de subprocesos que ejecutan tareas de forma asincrónica. Cuando lo usas Sin embargo, el objeto promete que ejecutará la operación en algún momento y le dará el resultado cuando lo solicite. Esto significa que se bloqueará cuando solicite el resultado y no haya finalizado, pero se ejecutará en el grupo de subprocesos de lo contrario.

Desde allí puede optimizar cosas: algunas operaciones se pueden implementar de manera sincronizada y puede optimizar cosas como el archivo I / O y la comunicación de red al agrupar las solicitudes subsiguientes y / o reordenarlas. No estoy seguro de si esto ya está en el marco de tareas de Microsoft, pero si no fuera eso, sería una de las primeras cosas que agregaría.

En realidad, puede implementar el patrón de clasificación futuro con rendimientos en C # 4.0. Si desea saber cómo funciona exactamente, puedo recomendar este enlace que hace un trabajo decente: http://code.google.com/p/fracture/source/browse/trunk/Squared/TaskLib/ . Sin embargo, si comienza a jugar con usted mismo, notará que realmente necesita soporte de idiomas si desea hacer todas las cosas interesantes, que es exactamente lo que hizo Microsoft.




Todas las respuestas aquí usan Task.Delay () o alguna otra función incorporada asincrónica. Pero aquí está mi ejemplo que no usa ninguna de esas funciones asíncronas:

    // Starts counting to a large numbewr and then immediately displays message "i'm counting...". 
    // Then it waits for task to finish and displays "finished, press any key".
    static void asyncTest ()
    {
        Console.WriteLine("Started asyncTest()");
        Task<long> task = asyncTest_count();
        Console.WriteLine("Started counting, please wait...");
        task.Wait(); // if you comment this line you will see that message "Finished counting" will be displayed before we actually finished counting.
        //Console.WriteLine("Finished counting to " + task.Result.ToString()); // using task.Result seems to also call task.Wait().
        Console.WriteLine("Finished counting.");
        Console.WriteLine("Press any key to exit program.");
        Console.ReadLine();
    }

    static async Task<long> asyncTest_count()
    {
        long k = 0;
        Console.WriteLine("Started asyncTest_count()");
        await Task.Run(() =>
        {
            long countTo = 100000000;
            int prevPercentDone = -1;
            for (long i = 0; i <= countTo; i++)
            {
                int percentDone = (int)(100 * (i / (double)countTo));
                if (percentDone != prevPercentDone)
                {
                    prevPercentDone = percentDone;
                    Console.Write(percentDone.ToString() + "% ");
                }

                k = i;
            }
        });
        Console.WriteLine("");
        Console.WriteLine("Finished asyncTest_count()");
        return k;
    }



¿Los usa igual que los hilos de fondo de desove para realizar una lógica de larga duración?

Este artículo MDSN: Programación asincrónica con async y await (C #) lo explica explícitamente:

Las palabras clave async y await no provocan la creación de subprocesos adicionales. Los métodos asíncronos no requieren multithreading porque un método async no se ejecuta en su propio hilo. El método se ejecuta en el contexto de sincronización actual y usa el tiempo en la secuencia solo cuando el método está activo.




La forma en que lo entiendo es que también debe haber un tercer término agregado a la mezcla: Task .

Async es solo un calificador que le pones a tu método para decir que es un método asincrónico.

Task es el regreso de la función async . Se ejecuta de forma asincrónica.

await una Tarea. Cuando la ejecución del código llega a esta línea, el control salta de vuelta al llamante de la función original que le rodea.

Si, en cambio, asigna el retorno de una función async (es decir, Task ) a una variable, cuando la ejecución del código llega a esta línea, simplemente continúa más allá de esa línea en la función circundante mientras la Task ejecuta de forma asíncrona.




En el siguiente código, el método HttpClient GetByteArrayAsync devuelve una Tarea, getContentsTask. La tarea es una promesa de producir la matriz de bytes real cuando se completa la tarea. El operador await se aplica a getContentsTask para suspender la ejecución en SumPageSizesAsync hasta que se complete getContentsTask. Mientras tanto, el control se devuelve a la persona que llama de SumPageSizesAsync. Cuando getContentsTask finaliza, la expresión await se evalúa como una matriz de bytes.

private async Task SumPageSizesAsync()
{
    // To use the HttpClient type in desktop apps, you must include a using directive and add a 
    // reference for the System.Net.Http namespace.
    HttpClient client = new HttpClient();
    // . . .
    Task<byte[]> getContentsTask = client.GetByteArrayAsync(url);
    byte[] urlContents = await getContentsTask;

    // Equivalently, now that you see how it works, you can write the same thing in a single line.
    //byte[] urlContents = await client.GetByteArrayAsync(url);
    // . . .
}