[C#] Cómo y cuándo usar `async` y` await`


Answers

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

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



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




public static void Main(string[] args)
{
    string result = DownloadContentAsync().Result;
    Console.ReadKey();
}

// You use the async keyword to mark a method for asynchronous operations.
// The "async" modifier simply starts synchronously the current thread. 
// What it does is enable the method to be split into multiple pieces.
// The boundaries of these pieces are marked with the await keyword.
public static async Task<string> DownloadContentAsync()// By convention, the method name ends with "Async
{
    using (HttpClient client = new HttpClient())
    {
        // When you use the await keyword, the compiler generates the code that checks if the asynchronous operation is finished.
        // If it is already finished, the method continues to run synchronously.
        // If not completed, the state machine will connect a continuation method that must be executed WHEN the Task is completed.


        // Http request example. 
        // (In this example I can set the milliseconds after "sleep=")
        String result = await client.GetStringAsync("http://httpstat.us/200?sleep=1000");

        Console.WriteLine(result);

        // After completing the result response, the state machine will continue to synchronously execute the other processes.


        return result;
    }
}



Explicación

Aquí hay un ejemplo rápido de async / await en un nivel alto. Hay muchos más detalles para considerar más allá de esto.

Nota: Task.Delay(1000) simplemente "funciona" durante 1 segundo. Creo que es mejor pensar en esto como esperar una respuesta de un recurso externo. Debido a que nuestro código simplemente está esperando una respuesta, el sistema puede establecer la tarea de ejecución a un lado y volver a ella una vez que haya finalizado. Mientras tanto, puede hacer otro trabajo mientras espera que termine.

En el siguiente ejemplo, el primer bloque está haciendo exactamente eso. Inicia todas las tareas de inmediato (las líneas Task.Delay ) y las pone a un lado. El código se detendrá en await a línea hasta que se complete el retraso de 1 segundo. Como b , c , d y e comenzaron casi al mismo tiempo que a (debido a que no hay espera / pausa), deberían terminar más o menos al mismo tiempo en este caso.

En el siguiente ejemplo, el segundo bloque está comenzando una tarea y esperando que termine antes de comenzar las tareas siguientes. Cada iteración de esto toma 1 segundo. La await está pausando el programa y esperando el resultado antes de continuar. Esta es la principal diferencia entre el primer y el segundo bloque.

Ejemplo

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)

Información adicional sobre SynchronizationContext

Nota: Aquí es donde las cosas se ponen un poco confusas, así que si me equivoco en algo, por favor corrígeme y actualizaré la respuesta. Es importante tener una comprensión básica de cómo funciona esto, pero puede salir adelante sin ser un experto siempre que nunca use ConfigureAwait(false) , aunque es probable que pierda alguna oportunidad de optimización, supongo.

Hay un aspecto de esto que hace que el concepto async / await sea algo más difícil de captar. Ese es el hecho de que en este ejemplo, todo esto sucede en el mismo hilo (o al menos lo que parece ser el mismo hilo en lo que respecta a SynchronizationContext). De forma predeterminada, await restablecerá el contexto de sincronización del subproceso original en el que se estaba ejecutando. Por ejemplo, en ASP.NET tiene un HttpContext que está vinculado a un hilo cuando entra una solicitud. Este contexto contiene elementos específicos de la solicitud Http original, como el objeto Request original que tiene cosas como el idioma, la dirección IP, los encabezados, etc. Si cambia los hilos a la mitad del procesamiento de algo, podría terminar tratando de extraer información de este objeto en un HttpContext diferente que podría ser desastroso. Si sabe que no usará el contexto para nada, puede elegir "no importarle". Esto básicamente permite que su código se ejecute en un hilo separado sin traer el contexto alrededor.

¿Cómo lo logras? Por defecto, el await a; En realidad, el código es suponer que DESEA capturar y restaurar el contexto:

await a; //Same as the line below
await a.ConfigureAwait(true);

Si desea permitir que el código principal continúe en un nuevo hilo sin el contexto original, simplemente use falso en lugar de verdadero para que sepa que no necesita restaurar el contexto.

await a.ConfigureAwait(false);

Una vez que el programa finalice en pausa, continuará potencialmente en un hilo completamente diferente con un contexto diferente. De aquí surgiría la mejora del rendimiento: podría continuar en cualquier hilo disponible sin tener que restaurar el contexto original con el que comenzó.

¿Esto es confuso? ¡Demonios si! ¿Puedes averiguarlo? ¡Probablemente! Una vez que tenga una comprensión de los conceptos, continúe con las explicaciones de Stephen Cleary, que tienden a orientarse más hacia alguien con una comprensión técnica de async / await ya.




Las respuestas aquí son útiles como una guía general sobre await / async. También contienen algunos detalles sobre cómo está cableado await / async. Me gustaría compartir con ustedes algunas experiencias prácticas que deben conocer antes de usar este patrón de diseño.

El término "esperar" es literal, por lo que cualquier hilo que lo invoque esperará el resultado del método antes de continuar. En el hilo de primer plano , esto es un desastre . El subproceso en primer plano conlleva la carga de construir su aplicación, incluidas vistas, modelos de vista, animaciones iniciales y cualquier otra cosa que haya ajustado para arrancar con esos elementos. Entonces, cuando esperas el hilo de primer plano, paras la aplicación. El usuario espera y espera cuando nada parece suceder. Esto proporciona una experiencia de usuario negativa.

Sin duda puede esperar un hilo de fondo utilizando una variedad de medios:

Device.BeginInvokeOnMainThread(async () => { await AnyAwaitableMethod(); });

// Notice that we do not await the following call, 
// as that would tie it to the foreground thread.
try
{
Task.Run(async () => { await AnyAwaitableMethod(); });
}
catch
{}

El código completo para estas observaciones se encuentra en https://github.com/marcusts/xamarin-forms-annoyances . Vea la solución llamada AwaitAsyncAntipattern.sln.

El sitio de GitHub también proporciona enlaces a una discusión más detallada sobre este tema.




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



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.




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 las aplicaciones web que ven una gran cantidad de solicitudes concurrentes al inicio o tienen una carga de ráfagas (donde la concurrencia aumenta repentinamente), hacer que estas llamadas al servicio web sean asincrónicas 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.