c# - Cómo y cuándo usar 'async' y 'esperar'



10 Answers

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

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

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 de espera aplicado a una tarea, WaitSynchronically se ejecuta de forma síncrona 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";
}
c# .net asynchronous async-await

A mi entender, una de las principales cosas que async y await hacen es hacer que el código sea fácil de escribir y leer, pero ¿se está utilizando de forma similar a los subprocesos de fondo para generar lógica de larga duración?

Actualmente estoy probando el ejemplo más básico. He añadido algunos comentarios en línea. ¿Me lo puedes aclarar?

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



Explicación

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

Nota: Task.Delay(1000) simula hacer trabajo durante 1 segundo. Creo que es mejor pensar en esto como esperando una respuesta de un recurso externo. Debido a que nuestro código está esperando una respuesta, el sistema puede hacer que la tarea se ejecute y volver a ella una vez que haya terminado. Mientras tanto, puede hacer algún otro trabajo en ese hilo.

En el siguiente ejemplo, el primer bloque está haciendo exactamente eso. Inicia todas las tareas inmediatamente (las líneas Task.Delay ) y las pone a un lado. El código se detendrá en la línea de await a hasta que se realice el retraso de 1 segundo antes de pasar a la línea siguiente. Como b , c , d , y e comenzaron a ejecutarse casi al mismo tiempo que a (debido a la falta de espera), deben terminar aproximadamente al mismo tiempo en este caso.

En el ejemplo a continuación, el segundo bloque está iniciando una tarea y esperando a que termine (eso es lo que await ) antes de comenzar las tareas subsiguientes. Cada iteración de esto toma 1 segundo. La await es pausar el programa y esperar 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 para mí, así que si me equivoco en algo, corríjame y actualizaré la respuesta. Es importante tener una comprensión básica de cómo funciona esto, pero puede subsistir sin ser un experto en ello siempre y cuando nunca use ConfigureAwait(false) , aunque supongo que perderá alguna oportunidad de optimización.

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

¿Cómo lograr esto? Por defecto, la await a; el código en realidad supone que QUIERES 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 es necesario restaurar el contexto.

await a.ConfigureAwait(false);

Una vez que el programa haya terminado de pausarse, continuará potencialmente en un subproceso completamente diferente con un contexto diferente. Aquí es de donde vendría la mejora del rendimiento: podría continuar en cualquier subproceso disponible sin tener que restaurar el contexto original con el que comenzó.

¿Esto es confuso? ¡Demonios si! ¿Puedes averiguarlo? ¡Probablemente! Una vez que haya comprendido los conceptos, continúe con las explicaciones de Stephen Cleary, que tienden a estar más orientadas hacia alguien con un conocimiento técnico de asíncrono / espera.




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

El punto de una tarea async es dejar 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", solo duerme y, por lo tanto, se llega a la siguiente línea después de 5 segundos ...

Lea 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




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

Al utilizar async / await en el controlador MVC, es posible aumentar la utilización del conjunto 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 simultáneas en el inicio o que tienen una carga repentina (donde la concurrencia aumenta repentinamente), hacer que estas llamadas de servicio web sean asíncronas aumentará la capacidad de respuesta de su aplicación. Una solicitud asíncrona toma la misma cantidad de tiempo para procesarse como 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 si se realiza de forma síncrona o asíncrona. Sin embargo, durante una llamada asíncrona, un subproceso no está bloqueado para responder a otras solicitudes mientras espera a que se complete la primera solicitud. Por lo tanto, las solicitudes asíncronas evitan la puesta en cola de solicitudes y el crecimiento del grupo de subprocesos cuando hay muchas solicitudes simultáneas que invocan operaciones de larga ejecución.




Todas las respuestas aquí usan Task.Delay () o alguna otra función asíncrona integrada. 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;
    }



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



Según entiendo también, debería agregarse un tercer término a la mezcla: Task .

Async es solo un calificador que usted pone en su método para decir que es un método asíncrono.

Task es el retorno de la función async . Se ejecuta de forma asíncrona.

Usted await una tarea. Cuando la ejecución del código llega a esta línea, el control salta al llamante de la función original que lo 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 la tarea está completa. 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 en SumPageSizesAsync. Cuando finaliza getContentsTask, la expresión de espera 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);
    // . . .
}



Async / Await

Acctually Async / Await son un par de palabras clave que son solo azúcar sintáctica para crear una devolución de llamada de una tarea asíncrona.

Tomemos como ejemplo esta operación:

    public static void DoSomeWork()
    {
        var task = Task.Run(() =>
        {
            // [RUNS ON WORKER THREAD]

            // IS NOT bubbling up due to the different threads
            throw new Exception();
            Thread.Sleep(2000);

            return "Hello";
        });

        // This is the callback
        task.ContinueWith((t) => {
            // -> Exception is swallowed silently
            Console.WriteLine("Completed");

            // [RUNS ON WORKER THREAD]
        });
    }

Este método tiene desventajas servales. Los errores no se transmiten y es extremadamente difícil de leer. Pero Async y Await vienen a ayudarnos:

    public async static void DoSomeWork()
    {
        var result = await Task.Run(() =>
        {
            // [RUNS ON WORKER THREAD]

            // IS bubbling up
            throw new Exception();
            Thread.Sleep(2000);

            return "Hello";
        });

        // every thing below is a callback 
        // (including the calling methods)

        Console.WriteLine("Completed");

    }

Las llamadas de espera tienen que estar en métodos asíncronos. Esto tiene algunas ventajas:

  • Devuelve el resultado de la tarea.
  • crea automáticamente una devolución de llamada
  • comprueba los errores y los deja crecer en la pila de llamadas (solo hasta las llamadas no esperadas en la pila de llamadas)
  • espera el resultado
  • libera el hilo principal
  • ejecuta la devolución de llamada en el hilo principal
  • utiliza un subproceso de trabajo del conjunto de subprocesos para la tarea
  • hace que el código sea fácil de leer
  • y mucho más

NOTA : Async y Await se utilizan con llamadas asíncronas para no realizarlas. Tienes que usar la biblioteca de tareas para esto, como Task.Run ().

Aquí hay una comparación entre esperar y ninguna espera soluciones.

Esta es la solución ninguno asincrónica:

    public static long DoTask()
    {
        stopWatch.Reset();
        stopWatch.Start();

        // [RUNS ON MAIN THREAD]
        var task = Task.Run(() => {
            Thread.Sleep(2000);
            // [RUNS ON WORKER THREAD]
        });
        Thread.Sleep(1000);
        // goes directly further
        // WITHOUT waiting until the task is finished

        // [RUNS ON MAIN THREAD]

        stopWatch.Stop();
        // 50 milliseconds
        return stopWatch.ElapsedMilliseconds;
    }

Este es el método asíncrono:

    public async static Task<long> DoAwaitTask()
    {
        stopWatch.Reset();
        stopWatch.Start();

        // [RUNS ON MAIN THREAD]

        await Task.Run(() => {
            Thread.Sleep(2000);
            // [RUNS ON WORKER THREAD]
        });
        // Waits until task is finished

        // [RUNS ON MAIN THREAD]

        stopWatch.Stop();
        // 2050 milliseconds
        return stopWatch.ElapsedMilliseconds;
    }

Accuually puede llamar a un método asíncrono sin la palabra clave await, pero esto significa que cualquier excepción aquí se ingiere en modo de liberación:

    public static Stopwatch stopWatch { get; } = new Stopwatch();

    static void Main(string[] args)
    {
        Console.WriteLine("DoAwaitTask: " + DoAwaitTask().Result + " ms");
        // 2050 (2000 more because of the await)
        Console.WriteLine("DoTask: " + DoTask() + " ms");
        // 50
        Console.ReadKey();
    }

Async y Await no están diseñados para la computación paralela. Se utilizan para no bloquear su hilo principal. Si se trata de asp.net o de las aplicaciones de windows. Bloquear el hilo principal debido a una llamada de red es algo malo. Si haces esto, tu aplicación dejará de responder o podría fallar.

Echa un vistazo a ms docs para obtener algunos ejemplos.

Espero que esto ayude;




A continuación se muestra el código que lee el archivo de Excel abriendo el diálogo y luego usa async y espera para ejecutar de forma asíncrona el código que lee una por una línea de excel y se enlaza a la cuadrícula

    namespace EmailBillingRates
{
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        lblProcessing.Text = "";
    }

    private async void btnReadExcel_Click(object sender, EventArgs e)
    {
        string filename = OpenFileDialog();

        Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();
        Microsoft.Office.Interop.Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(filename);
        Microsoft.Office.Interop.Excel._Worksheet xlWorksheet = xlWorkbook.Sheets[1];
        Microsoft.Office.Interop.Excel.Range xlRange = xlWorksheet.UsedRange;
        try
        {
            Task<int> longRunningTask = BindGrid(xlRange);
            int result = await longRunningTask;

        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message.ToString());
        }
        finally
        {
            //cleanup  
           // GC.Collect();
            //GC.WaitForPendingFinalizers();

            //rule of thumb for releasing com objects:  
            //  never use two dots, all COM objects must be referenced and released individually  
            //  ex: [somthing].[something].[something] is bad  

            //release com objects to fully kill excel process from running in the background  
            Marshal.ReleaseComObject(xlRange);
            Marshal.ReleaseComObject(xlWorksheet);

            //close and release  
            xlWorkbook.Close();
            Marshal.ReleaseComObject(xlWorkbook);

            //quit and release  
            xlApp.Quit();
            Marshal.ReleaseComObject(xlApp);
        }

    }

    private void btnSendEmail_Click(object sender, EventArgs e)
    {

    }

    private string OpenFileDialog()
    {
        string filename = "";
        OpenFileDialog fdlg = new OpenFileDialog();
        fdlg.Title = "Excel File Dialog";
        fdlg.InitialDirectory = @"c:\";
        fdlg.Filter = "All files (*.*)|*.*|All files (*.*)|*.*";
        fdlg.FilterIndex = 2;
        fdlg.RestoreDirectory = true;
        if (fdlg.ShowDialog() == DialogResult.OK)
        {
            filename = fdlg.FileName;
        }
        return filename;
    }

    private async Task<int> BindGrid(Microsoft.Office.Interop.Excel.Range xlRange)
    {
        lblProcessing.Text = "Processing File.. Please wait";
        int rowCount = xlRange.Rows.Count;
        int colCount = xlRange.Columns.Count;

        // dt.Column = colCount;  
        dataGridView1.ColumnCount = colCount;
        dataGridView1.RowCount = rowCount;

        for (int i = 1; i <= rowCount; i++)
        {
            for (int j = 1; j <= colCount; j++)
            {
                //write the value to the Grid  
                if (xlRange.Cells[i, j] != null && xlRange.Cells[i, j].Value2 != null)
                {
                     await Task.Delay(1);
                     dataGridView1.Rows[i - 1].Cells[j - 1].Value =  xlRange.Cells[i, j].Value2.ToString();
                }

            }
        }
        lblProcessing.Text = "";
        return 0;
    }
}

internal class async
{
}

} `




Related