CodeGym /Cursos /C# SELF /Palabras clave async y await

Palabras clave async y await

C# SELF
Nivel 59, Lección 2
Disponible

1. Introducción

Antes de saltar al código, aclaremos la motivación y pongamos una situación típica. Supongamos que tu programa descarga un archivo desde internet:

// Pseudocódigo
var data = DownloadFile("https://example.com/file");
ProcessData(data);

El problema es el siguiente: mientras se realiza la descarga, el programa "se queda congelado". No se ejecutan otras acciones — el usuario no puede mover el ratón, ni pulsar botones, ni siquiera esperar el final sin una aburrida ventana "colgada".

Antes (y en otros lenguajes) para resolver esto había que usar hilos (Thread), tareas (Task), delegates, timers — todo eso llevaba a código enmarañado, difícil de leer y mantener. En C# el equipo decidió facilitar la vida: apareció la asincronía con las palabras clave async y await. Ahora puedes escribir código asincrónico casi igual que el normal.

El clásico "dolor" asincrónico sin async/await

Para contraste, veamos cómo sería ejecutar una operación larga con hilos si quisiéramos no bloquear la interfaz:

// Ejemplo sin async/await, manualmente
var thread = new Thread(() =>
{
    var data = DownloadFile("https://example.com/file");
    Console.WriteLine("¡Archivo descargado!");
});
thread.Start();

Este enfoque es bastante tosco: tienes que manejar hilos manualmente, no hay una forma sencilla de "esperar" el resultado, y manejar errores es complicado.

2. Asincronía en C#: sintaxis

Definición: ¿qué son async y await?

async — es un modificador que prohíbe que un método sea aburrido y lo hace asincrónico. Ese método normalmente devuelve Task (o Task<T>), o ValueTask. Es una promesa de que el resultado llegará, pero un poco más tarde (como un pedido en una tienda online — pides y esperas).

await — es un operador que dice: "Detente en esta línea cuando llegues a ella. Espera a que la operación termine, pero no bloquees el hilo. El resto puede seguir haciendo cosas".

¿Cómo se ve un método asincrónico?

public async Task MyAsyncMethod()
{
    Console.WriteLine("Cargando archivo...");
    var data = await DownloadFileAsync("https://example.com/file"); // ¡Esperamos el resultado de forma asincrónica!
    Console.WriteLine("¡Listo!");
}

Fíjate:

  • Al método se le añadió el modificador async.
  • Dentro del método se usa await para la operación asincrónica.
  • El método devuelve Task (o Task<T>, si hay un valor de retorno).

Visualización: ¿qué pasa al llamar a un método async?

graph LR
A[Llamada a MyAsyncMethod] --> B[Ejecución hasta el await]
B --> C[Llamada a DownloadFileAsync]
C --> D{Esperando}
D --> |Archivo no descargado| E[Liberación del hilo]
D --> |Archivo descargado| F[Ejecución después del await]
F --> G[Finalización del método]
  • Hasta el primer await el método se ejecuta de forma síncrona.
  • En el await la ejecución del método se suspende, el control vuelve al código llamador.
  • Cuando la operación asincrónica termina, la ejecución continúa después del await — como si nada hubiera pasado.

3. Ejemplo: descarga asincrónica usando async/await

Que nuestra app de aprendizaje descargue texto desde internet y imprima su longitud sin bloquear el resto del código.

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    // Método asincrónico (devuelve Task)
    public static async Task DownloadAndPrintLengthAsync(string url)
    {
        Console.WriteLine("Empezando la descarga...");

        // Usamos HttpClient — soporta métodos asincrónicos
        using (var client = new HttpClient())
        {
            string data = await client.GetStringAsync(url);
            Console.WriteLine($"¡Descarga completada! Longitud del texto: {data.Length} caracteres.");
        }

        Console.WriteLine("El método ha terminado su trabajo.");
    }

    static void Main()
    {
        // Lanzamos la operación asincrónica y esperamos a que termine
        var task = DownloadAndPrintLengthAsync("https://www.example.com");
        task.Wait(); // Para ejemplos simples en consola esto está bien. En apps UI o web reales esta llamada bloqueará y puede causar deadlocks.
    }
}

Explicaciones:

  • DownloadAndPrintLengthAsync — completamente asincrónico, gracias a async y await.
  • Dentro del método esperamos la descarga asincrónica de la cadena usando await.
  • En Main() lanzamos la tarea y la esperamos explícitamente con Wait(). En C# moderno puedes hacer el propio Main asincrónico (async Task Main) y escribir simplemente await.

4. ¿Cómo funciona?

Diferencia entre código síncrono y asincrónico

VARIANTE SÍNCRONA

Console.WriteLine("Inicio");
string data = client.GetStringAsync(url).Result; // .Result bloquea el hilo!
Console.WriteLine("Operación completada");

VARIANTE ASINCRÓNICA

Console.WriteLine("Inicio");
string data = await client.GetStringAsync(url); // El hilo no se bloquea
Console.WriteLine("Operación completada");

¿Qué hace await "bajo el capó"?

Cuando usas await, C# automáticamente "divide" tu método en dos (o más) partes: todo lo que está antes del await, y todo lo que está después. Cuando el método asincrónico llamado devuelve un Task, tu método retorna al código llamador, y cuando ese Task termina — la ejecución continúa después del await. Todo esto ocurre automáticamente; no necesitas preocuparte por hilos y cambios de contexto manualmente.

Dato interesante: C# "convierte" tu método asincrónico en una máquina de estados, donde cada "await" es un nuevo "punto de retorno".

Uso de async/await en aplicaciones reales

static async Task Main(string[] args)
{
    var downloadTask = DownloadAndPrintLengthAsync("https://www.example.com");
    // Mientras descarga, hacemos otra cosa
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine($"Trabajando... iteración {i}");
        await Task.Delay(500); // Pausa de 0.5s, simulamos trabajo
    }
    await downloadTask; // Esperamos a que la descarga termine
}

Ahora el programa descarga algo y no se bloquea: "multitarea viva", casi como un gato que a la vez duerme y vigila su cuenco.

Asincronía ≠ multihilo

Una distinción importante que los novatos suelen confundir: el código asincrónico puede ejecutarse en el mismo hilo. La asincronía trata de no bloquear el hilo, no de crear hilos nuevos necesariamente. Los hilos del SO son recursos caros. La asincronía permite "liberar" el hilo para que siga trabajando sin esperar operaciones largas (de red, disco, timers, etc.).

Tabla comparativa: ¿cuándo elegir qué?

Escenario Thread/Task async/await
Tareas CPU-bound Sí Sí (a través de Task.Run)
Tareas I/O-bound Poco eficiente Ideal
Mucho paralelismo Complicado Sencillo
Simplicidad del código Hardcore Fácil de leer

5. Matices útiles

Main asincrónico

En versiones modernas de C# puedes hacer el método Main asincrónico.

static async Task Main(string[] args)
{
    // Todo tu código asincrónico puede await-arse directamente en Main
    await DownloadAndAnalyzeFileAsync("https://example.com/file");
}

Error típico: olvidarse del await — la tarea "se fuga"

SomeAsyncFunction(); // no hacemos await, ¡nadie espera a que termine!

Como resultado, esa tarea se ejecutará "en vacío" — y si ocurre un error, ¡ni te enterarás!

Cuándo NO escribir métodos async

  • Si dentro del método no hay ninguna operación asincrónica (ningún await), no hace falta marcarlo como async.
  • No escribas métodos con async void (salvo que seas un manejador de eventos).

Reglas rápidas y preguntas frecuentes

  • ¿Se puede usar await fuera de un método async? No. Siempre solo dentro de métodos marcados como async.
  • ¿Se pueden tener varios await en un mismo método? Sí, tantos como quieras — cada uno es un "punto de espera".
  • ¿Y si quiero devolver un resultado? Usa Task<T> y escribe return.
  • ¿Se pueden combinar varias tareas asincrónicas? Claro. Puedes arrancar varias tareas en paralelo y esperar a todas con Task.WhenAll.

6. Errores típicos al usar async/await

Error nº1: "bola de fuego" — await después de llamar a la tarea asincrónica.

DownloadAndPrintLengthAsync("https://www.example.com");
Console.WriteLine("¡Todo hecho!"); // En realidad la descarga aún sigue

El código NO esperará a que termine la operación asincrónica. Todas las tareas asincrónicas deben ser o bien await-eadas, o bien esperadas explícitamente con Wait() (pero esta segunda forma es peligrosa y puede causar bloqueos).

Error nº2: mezclar código síncrono y asincrónico con .Result o .Wait().

Es un antipatrón que anula todas las ventajas de la asincronía. En apps UI o ASP.NET esto casi seguro causará un deadlock: la tarea asincrónica espera a que el hilo se libere, y el hilo está bloqueado esperando la tarea. Recuerda el mantra: "async all the way" (asincronía hasta arriba).

Error nº3: usar async void.

Los métodos async void no pueden ser esperados (await), y las excepciones lanzadas desde ellos no se pueden capturar con try-catch normal y suelen provocar la terminación abrupta de la aplicación. El único uso aceptable de async void son los manejadores de eventos (por ejemplo, async void Button_Click(...)), donde la firma lo exige. En el resto de casos usa async Task.

Error nº4: async sobrante en un método sin await.

Si marcas un método como async pero no usas dentro ningún await, el compilador advertirá. Ese código se ejecutará totalmente de forma síncrona, pero con sobrecarga adicional por crear una "máquina de estados" innecesaria. Esto confunde y degrada el rendimiento.

2
Tarea
C# SELF, nivel 59, lección 2
Bloqueada
Método asíncrono con pausa
Método asíncrono con pausa
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION