.Net Asincrónico #2

En el post anterior vimos una pequeña introducción a las características que posee .Net para trabajar asincrónicamente. Es este post veremos cómo crear nuestros métodos asincrónicos, como manejar las excepciones y buenas prácticas al usar este paradigma.

Nuestro método asincrónico

Todo el tiempo deberíamos pensar en que nuestro código no debería ser muy extenso. Recordemos que nuestro código debe estar lo más limpio posible, por eso, vamos a refactorizar el código del post anterior que era el siguiente:

private async void button_Click(object sender, RoutedEventArgs e)
{

    using (var client = new HttpClient())
    {

        var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);

        try {

            result.EnsureSuccessStatusCode();

            var content = await result.Content.ReadAsStringAsync();

            var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);

            CustomersGrid.ItemsSource = data;

        } catch (Exception ex) {
            txtOut.Text += ex.Message;
        }
    }
    
}

Haremos los siguientes cambios, crearemos un método que llamaremos GetPeople(). Nos aseguraremos de que nuestra aplicación no modifique su comportamiento a pesar de estar en un método separado. Modificaremos nuestro código. Se verá de la siguiente manera:

private async void button_Click(object sender, RoutedEventArgs e)
{
    await GetPeople(search);
}

public async Task GetPeople(string search) {

    using (var client = new HttpClient())
    {

        var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);

        try
        {

            result.EnsureSuccessStatusCode();

            var content = await result.Content.ReadAsStringAsync();

            var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);

            CustomersGrid.ItemsSource = data;

        }
        catch (Exception ex)
        {
            txtOut.Text += ex.Message;
        }
    }
}

Lo primero que podemos notar es que nuestro método GetPeople() es declarado como async y Task. Nota: no debemos hacer métodos async que devuelva un tipo void solo debemos usarlo cuando son eventos manejados (Event Handlers).

Declararlo como Task significa que el método devolverá una referencia automáticamente a la operación que se encuentra en curso y que en algún momento será invocada esperando la resolución. Visual Studio no mostrará ningún error, esto se debe a que un método declarado como async task explícitamente debe devolver algo y el compilador se encargará de ello.

En nuestro evento clic invocamos GetPeople() y decláralo con la palabra clave await para que sepa que debe esperar. Veamos en la imagen que nada ha cambiado:

Es muy fácil refactorizar nuestro código creando un método asincrónico. Al hacerlo hicimos que nuestro código fuera un poco más legible. Recordemos, nuevamente, que este enfoque puede ser aplicado en cualquier entorno de .Net, ASP.Net, consola, Xamarin, etc.

Excepciones

Debemos tener en cuenta que a veces nuestros métodos pueden fallar. Supongamos que nuestro método está llamando al api pero que en ese momento no se encuentra disponible. Nuestra aplicación fallará. Por esta razón es tan importante la palabra clave await. Esta nos garantiza que la excepción sea controlada, y si no la usamos, la aplicación nunca se enterara que ha ocurrido una excepción.

Visual Studio nos avisara cuando tenemos una llamada a un método que devuelve un Task y no está siendo invocado con la palabra  await.

Otro ejemplo serio, ¿Qué pasa si lo pongo en un bloque try..catch?

Pasaría exactamente lo mismo, la excepción no será controlada. Pero si agregamos la palabra clave await podremos manejar la excepción.

Otro punto importante, que tocamos con anterioridad, es porque los métodos async no deben ser void. La razón es que los métodos void no puede ser controladas sus excepciones debido a que no devuelven nada. Al usar Task nos aseguramos de que algo sea devuelto.

Por esta razón, es muy importante la combinación await y async Task. Gracias a esta combinación podemos asegurarnos de que podremos controlar las excepciones. El método devolverá un tipo y al ser invocado se quedará esperando que suceda algo.

Buenas Prácticas y Conclusiones

Recordemos donde podemos usar estas prácticas en .Net:

• Windows Presentation Foundation
• Windows Forms
• Xamarin
• Aplicaciones de consola
• Asp.Net

Esto quiere decir que podemos utilizarlo en cualquier tipo de aplicación .Net que necesitemos. La única diferencia es que en ASP.Net no posee una interface de usuario, pero nos ayudará a alivianar la carga en el servidor web.

Hagamos un resumen de es incorrecto y qué es correcto:

Espero que la información les sea útil y cubra todas las necesidades que les surjan. En próximos posts tocaré más temas sobre programación sincrónica y paralela.