0Pricing
C# Academy · Lección

ConfigureAwait y flujo de excepciones

Comprenda la captura de contexto y ConfigureAwait(false); gestione excepciones con await frente a llamadas bloqueantes, y conozca AggregateException y las prácticas recomendadas.

ConfigureAwait y flujo de excepciones es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Contexto y excepciones

Objetivos:

  • Comprenda qué es la captura de contexto
  • Sepa cuándo usar ConfigureAwait(false)
  • Comprenda cómo fluyen las excepciones con await
  • Comprenda por qué el bloqueo produce AggregateException

Práctica recomendada para bibliotecas

Los métodos de biblioteca deben usar ConfigureAwait(false) para evitar reanudar la ejecución en un contexto de UI/web que no controlan.

using System;
using System.Threading.Tasks;

public static class NetLib
{
  // Library code should not assume a UI context. Use ConfigureAwait(false).
  public static async Task<string> FetchAsync()
  {
    await Task.Delay(100).ConfigureAwait(false); // do not capture context
    return "payload";
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    // Console apps typically have no SynchronizationContext; this still runs fine.
    string s = NetLib.FetchAsync().GetAwaiter().GetResult();
    Console.WriteLine("Got: " + s);
  }
}

Reglas del contexto

Captura de contexto:

  • El await predeterminado intenta reanudar la ejecución en el contexto capturado (UI/ASP.NET)
  • ConfigureAwait(false) indica que no se capture el contexto y que la ejecución se reanude en el grupo de subprocesos
  • Ayuda a evitar interbloqueos cuando quienes realizan las llamadas bloquean el subproceso del contexto
  • El código de UI puede necesitar el contexto para actualizar controles; el código de biblioteca normalmente no debería necesitarlo

Await y excepciones

Al usar await, la excepción se propaga como la excepción original; captúrela normalmente.

using System;
using System.Threading.Tasks;

public class Program
{
  static async Task<string> BoomAsync()
  {
    await Task.Delay(50);
    throw new InvalidOperationException("boom");
  }

  public static void Main(string[] args)
  {
    // With await (inside async), exceptions rethrow as the original type.
    try
    {
      string r = BoomAsync().GetAwaiter().GetResult(); // emulate await in Main
      Console.WriteLine(r);
    }
    catch (InvalidOperationException ex)
    {
      Console.WriteLine("Caught: " + ex.GetType().Name + " - " + ex.Message);
    }
  }
}

Bloqueo y errores

Bloquear con .Result o .Wait() envuelve los errores en AggregateException; prefiera await para que el flujo de errores sea más claro.

using System;
using System.Threading.Tasks;

public class Program
{
  static async Task<int> FailsAsync()
  {
    await Task.Delay(30);
    throw new ArgumentException("bad arg");
  }

  public static void Main(string[] args)
  {
    try
    {
      // Blocking with .Result wraps the exception into AggregateException
      int x = FailsAsync().Result;
      Console.WriteLine(x);
    }
    catch (AggregateException ae)
    {
      Exception inner = ae.InnerException;
      Console.WriteLine("AggregateException -> " + (inner == null ? "null" : inner.GetType().Name));
    }
  }
}

Prácticas recomendadas

Directrices:

  • En bibliotecas: use ConfigureAwait(false)
  • En UI/web: use await en el subproceso que realiza la llamada cuando necesite el contexto
  • Evite .Result/.Wait(); capture las excepciones originales con await
  • Registre y vuelva a lanzar las excepciones con mensajes que incluyan el contexto si es necesario

Comportamiento de ConfigureAwait

Comprobación rápida: ¿Qué le indica ConfigureAwait(false) a una expresión await?

Resumen

Resumen: Use ConfigureAwait(false) en bibliotecas; deje que el código de UI/web decida cuándo necesita el contexto. Prefiera await para que el flujo de excepciones sea claro; el bloqueo envuelve los errores y puede provocar interbloqueos.

Preguntas frecuentes

¿La lección «ConfigureAwait y flujo de excepciones» es gratis?

Sí — el texto completo de «ConfigureAwait y flujo de excepciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «ConfigureAwait y flujo de excepciones»?

Comprenda la captura de contexto y ConfigureAwait(false); gestione excepciones con await frente a llamadas bloqueantes, y conozca AggregateException y las prácticas recomendadas. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «ConfigureAwait y flujo de excepciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Task/ValueTask y la máquina de estados async (conceptos)
  2. Errores comunes de async: sync-over-async y deadlocks
  3. ConfigureAwait y flujo de excepciones
← Volver a C# Academy