1. Introducción
Imagínate que tu código es una fila en el supermercado. Si ejecutas un método síncrono, toda la cola (tu hilo) espera a que el cajero termine con un cliente antes de pasar al siguiente. Si el método es asíncrono, simplemente dejas tus compras en la caja y te vas a hacer otras cosas, y cuando el cajero termine — te llamará.
Un método asíncrono (método async) en .NET es un método normal con una etiqueta especial "pegada" delante (async) que permite usar dentro el operador await para esperar de forma no bloqueante a otras operaciones asíncronas (por ejemplo, trabajo de red o con archivos) sin bloquear el hilo principal. Esa "pegatina" convierte la tienda síncrona aburrida en un servicio moderno sin colas.
Firma básica de un método asíncrono
Un método asíncrono se declara obligatoriamente con el modificador async en la firma. Aquí tienes el ejemplo más básico:
public async Task MyAsyncMethod()
{
// Tu código asíncrono aquí
}
Tipos de retorno de métodos asíncronos:
| Tipo de retorno | Descripción | Ejemplo |
|---|---|---|
|
El método hace trabajo asíncrono pero no devuelve resultado | |
|
El método hace trabajo asíncrono y devuelve un resultado de tipo T | |
|
Se usa solo para eventos. ¡No recomendado en el resto del código! | |
|
Para escenarios de alto rendimiento, cuando el resultado suele estar listo de forma síncrona | — |
Importante: ¡No uses async void en ningún sitio salvo en manejadores de eventos! Si no, corres el riesgo de quedarte sin un manejo correcto de errores.
2. Ejemplo sencillo de método asíncrono
Volvamos a nuestra aplicación de práctica (puede ser un programa de consola normal) y añadamos un método asíncrono que obtiene datos de la red. Vamos a emular la latencia.
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("Inicio del método asíncrono...");
await MyFakeDownloadAsync();
Console.WriteLine("¡Operación asíncrona completada!");
}
static async Task MyFakeDownloadAsync()
{
Console.WriteLine("Comenzando descarga (emulamos una espera de 2 seg)...");
await Task.Delay(2000); // Emulamos una operación larga
Console.WriteLine("¡Descarga completada!");
}
}
Comentarios sobre el ejemplo:
- La palabra clave async aparece en Main y en MyFakeDownloadAsync.
- El operador await solo se puede usar dentro de métodos marcados como async.
- El método Task.Delay(2000) emula una operación larga (por ejemplo, una petición de red).
- Después de encontrar await el hilo no se bloquea — la ejecución de Main "se suspende" hasta que termine la espera.
3. ¿Cómo funciona un método asíncrono por debajo?
Cuando el compilador ve un método con la palabra clave async, lo transforma en una "máquina de estados" que recuerda el punto donde se detuvo, las variables locales y continúa la ejecución después de que la operación awaited termine.
Aquí tienes un esquema muy simplificado:
+-----------------------------------------------------------+
| Llamada al método asíncrono (por ejemplo, await X) |
+-------------------------+---------------------------------+
|
v
¿La operación ha terminado? (no Task.Completed)
| |
| sí | no
v v
Suspender Devolver
ejecución, inmediatamente
recordar el resultado
el contexto
|
La operación asíncrona termina...
|
v
La máquina de estados "despierta" el método,
la ejecución continúa desde el punto tras el await
No hace falta memorizar los detalles: el contexto (el punto de parada y las variables locales) se guarda y se restaura automáticamente cuando la operación termina.
Dónde se puede (y no) usar las palabras clave async y await
- async se coloca antes de la declaración del método (o de la lambda).
- Dentro de un método async se puede (y debe) usar await.
- Si intentas escribir await en un método sin async — obtendrás un error de compilación.
- Si pones async pero no hay ningún await dentro — recibirás una advertencia; el método se ejecutará de forma síncrona y devolverá una tarea ya completada.
4. Variantes de valores de retorno y sus particularidades
Resultado Task
Si el método realiza acciones asíncronas pero no devuelve valor, usa Task:
public async Task SaveToFileAsync(string path)
{
await Task.Delay(1000);
// Guardamos algo en un archivo
}
Resultado Task<T>
Si necesitas un resultado, usa Task<T>:
public async Task<int> CalculateAsync()
{
await Task.Delay(500);
return 42;
}
Llamada:
int result = await CalculateAsync();
Resultado async void
Úsalo solo para eventos. Por ejemplo, el manejador de clic de un botón:
private async void Button_Click(object sender, EventArgs e)
{
await Task.Delay(1000);
// Hacemos algo más
}
¿Por qué no usar async void en métodos normales? Porque no sabrás cuándo ese método habrá terminado y no podrás capturar correctamente las excepciones que ocurran dentro de él.
Resultados ValueTask y ValueTask<T>
Aparecieron para bibliotecas de alto rendimiento, cuando el resultado suele estar ya listo de forma síncrona — permiten evitar allocations innecesarias de Task. Al empezar, puedes no usarlos: no se ven tan a menudo.
5. Ejemplo: calculadora asíncrona que devuelve resultado
Imagina que el programa calcula la suma de dos números "con retraso", como si fuera una operación muy compleja:
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("Introduce el primer número:");
int a = int.Parse(Console.ReadLine()!);
Console.WriteLine("Introduce el segundo número:");
int b = int.Parse(Console.ReadLine()!);
Console.WriteLine("Ejecutando cálculo...");
int sum = await CalculateSumAsync(a, b);
Console.WriteLine($"Suma: {sum}");
}
static async Task<int> CalculateSumAsync(int x, int y)
{
await Task.Delay(2000); // Operación "larga"
return x + y;
}
}
Qué es importante aquí:
- CalculateSumAsync — método asíncrono, devuelve Task<int>, dentro hay un await.
- La llamada en Main se hace usando await (recordatorio: desde C# 7.1 el método Main puede ser asíncrono).
- Mientras se calcula la suma, el hilo no se bloquea — se puede mostrar progreso o hacer otro trabajo.
6. Métodos anidados y await anidados
Un método asíncrono puede llamar a otro método asíncrono, y ese a su vez a otro. Toda la cadena continuará automáticamente:
public async Task<int> StartWorkAsync()
{
int data = await GetDataAsync();
int result = await ProcessDataAsync(data);
return result;
}
Es simple: esperamos a que termine una operación, luego a la siguiente.
7. Trampas y errores frecuentes
1. ¡No olvides async!
Si olvidas async, el compilador se quejará si ve await dentro y no te dejará compilar.
2. No uses async void en métodos normales
Los métodos asíncronos void (excepto manejadores de eventos) son agujeros negros para excepciones. Los errores en ellos pueden "ahogarse" y ni siquiera sabrás.
3. Método asíncrono SIN await
Se puede, pero no tiene sentido — el método se ejecutará de forma síncrona y devolverá una tarea ya completada.
public async Task DoNothingAsync()
{
// Uy, ¡no hay ningún await!
}
4. Devolver Task desde un método NO asíncrono
Se hace para unificar interfaces: parte de las operaciones son realmente asíncronas, otra parte son instantáneas.
public Task<int> Foo()
{
// return 42; // ¡Esto no se puede!
return Task.FromResult(42); // Se puede, pero aquí no hay asíncronía.
}
GO TO FULL VERSION