ConfigureAwait(false) en C# — La Explicación Completa

// Código detrás de WPF — ConfigureAwait(true) es el predeterminado
private async void Button_Click(object sender, RoutedEventArgs e)
{
    string result = await FetchDataAsync(); // se suspende aquí
    // Reanuda en el hilo de UI — seguro para tocar controles
    myLabel.Content = result;
}

string result = await FetchDataAsync().ConfigureAwait(false);
// Reanuda en un hilo del thread pool — NO tocar controles de UI aquí

// --- Flujo con ConfigureAwait(true) ---
// Hilo: hilo de UI (SynchronizationContext = DispatcherSynchronizationContext)
await Task.Delay(100);
// 1. Se captura DispatcherSynchronizationContext
// 2. Task.Delay completa en el hilo del thread pool T2
// 3. T2 publica la continuación en la cola del Dispatcher
// 4. El hilo de UI la recoge de la cola
// Hilo: hilo de UI nuevamente ✓
 
// --- Flujo con ConfigureAwait(false) ---
// Hilo: hilo de UI (SynchronizationContext = DispatcherSynchronizationContext)
await Task.Delay(100).ConfigureAwait(false);
// 1. El SynchronizationContext intencionalmente NO se captura
// 2. Task.Delay completa en el hilo del thread pool T2
// 3. La continuación se ejecuta directamente en T2 (sin ida y vuelta al Dispatcher)
// Hilo: hilo del thread pool T2

// Método de biblioteca — NO usa ConfigureAwait(false)
public async Task<string> GetDataAsync()
{
    await Task.Delay(500); // captura AspNetSynchronizationContext
    return "hello";
}
 
// Acción del controlador — bloquea de forma síncrona (mala práctica, pero ocurre)
public ActionResult Index()
{
    // .Result bloquea el hilo de la solicitud mientras mantiene el bloqueo del contexto
    string data = GetDataAsync().Result; // DEADLOCK
    return Content(data);
}

public async Task<string> GetDataAsync()
{
    // NO intenta volver al AspNetSynchronizationContext
    await Task.Delay(500).ConfigureAwait(false);
    return "hello"; // ejecuta en un hilo del thread pool — sin contexto necesario
}

// WPF: manejador de clic que llama .Result (nunca hagas esto en código real)
private void BadButton_Click(object sender, RoutedEventArgs e)
{
    // El hilo de UI se bloquea, retiene DispatcherSynchronizationContext
    string result = SomeLibraryMethod().Result; // deadlock si la biblioteca usa ConfigureAwait(true)
    myLabel.Content = result;
}
 
// Biblioteca — correcto: usa ConfigureAwait(false) en todas partes
public async Task<string> SomeLibraryMethod()
{
    var data = await HttpClient.GetStringAsync("https://example.com")
        .ConfigureAwait(false); // no intentará publicar de vuelta al Dispatcher
    return data.ToUpper();
}

// Controlador de ASP.NET Core — ConfigureAwait(false) no tiene efecto aquí
[HttpGet("data")]
public async Task<IActionResult> GetData()
{
    // Comportamiento idéntico con o sin ConfigureAwait(false)
    var result = await _service.FetchAsync();
    return Ok(result);
}

static async Task Main(string[] args)
{
    // No hay SynchronizationContext — ConfigureAwait(false) es redundante
    var data = await File.ReadAllTextAsync("input.txt").ConfigureAwait(false);
    Console.WriteLine(data);
}

// Buen código de biblioteca — agnóstico al contexto en todas partes
public class DataClient
{
    private readonly HttpClient _http;
 
    public DataClient(HttpClient http) => _http = http;
 
    public async Task<UserDto> GetUserAsync(int id)
    {
        // ConfigureAwait(false) en cada await — la biblioteca no posee el contexto
        var response = await _http.GetAsync($"/users/{id}").ConfigureAwait(false);
        response.EnsureSuccessStatusCode();
 
        var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
        return JsonSerializer.Deserialize<UserDto>(json)!;
    }
 
    public async Task<IReadOnlyList<OrderDto>> GetOrdersAsync(int userId)
    {
        var response = await _http.GetAsync($"/users/{userId}/orders").ConfigureAwait(false);
        response.EnsureSuccessStatusCode();
 
        await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
        var orders = await JsonSerializer.DeserializeAsync<List<OrderDto>>(stream).ConfigureAwait(false);
        return orders ?? [];
    }
}

public async Task ExampleAsync()
{
    // Aún en el contexto original
    await FirstOperation().ConfigureAwait(false);
 
    // Ahora en el hilo del thread pool — SynchronizationContext.Current es null
    // Este ConfigureAwait(true) es efectivamente igual a ConfigureAwait(false)
    // porque no hay contexto al que volver
    await SecondOperation().ConfigureAwait(true); // redundante — sin contexto presente
    await ThirdOperation(); // también está bien — sin contexto que capturar
}

dotnet add package Microsoft.VisualStudio.Threading.Analyzers

// Advertencia VSTHRD111: Usa .ConfigureAwait(false) al awaitar una tarea
var result = await SomeTaskAsync(); // ⚠ VSTHRD111

[*.cs]
dotnet_diagnostic.VSTHRD111.severity = error

dotnet add package Roslynator.Analyzers

[*.cs]
# CA2007: Considera llamar ConfigureAwait en la tarea awaited
dotnet_diagnostic.CA2007.severity = warning

// ConfigureAwaitOptions.None == ConfigureAwait(false)
await task.ConfigureAwait(ConfigureAwaitOptions.None);
 
// ConfigureAwaitOptions.ContinueOnCapturedContext == ConfigureAwait(true)
await task.ConfigureAwait(ConfigureAwaitOptions.ContinueOnCapturedContext);
 
// Nuevo: completa el await aunque la tarea haya fallado o sido cancelada — no
// relanza la excepción. Solo válido en Task no genérico (un Task<T> no tendría
// resultado que devolverte).
await task.ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
 
// Nuevo: siempre cede el control, incluso si la tarea ya completó — el await nunca
// continúa sincrónicamente. Útil para forzar equidad o salir de una ruta con lock.
await task.ConfigureAwait(ConfigureAwaitOptions.ForceYielding);
 
// Son flags, así que se combinan:
await task.ConfigureAwait(
    ConfigureAwaitOptions.SuppressThrowing | ConfigureAwaitOptions.ForceYielding);

<!-- Directory.Build.props — aplica a todos los proyectos en el árbol de directorio -->
<Project>
  <PropertyGroup>
    <!-- Tratar ConfigureAwait faltante como error de compilación en todo el repositorio -->
    <WarningsAsErrors>$(WarningsAsErrors);CA2007</WarningsAsErrors>
    <EnableNETAnalyzers>true</EnableNETAnalyzers>
    <AnalysisMode>All</AnalysisMode>
  </PropertyGroup>
</Project>

// NO hagas esto por "rendimiento" en ASP.NET Core — agrega ruido sin beneficio
public async Task<string> GetDataAsync()
{
    return await _cache.GetAsync("key").ConfigureAwait(false); // inútil en ASP.NET Core
}

public async Task DemonstrateExceptionAsync()
{
    try
    {
        // La excepción lanzada dentro de FetchAsync se relanza aquí,
        // independientemente de ConfigureAwait
        await FetchAsync().ConfigureAwait(false);
    }
    catch (HttpRequestException ex)
    {
        // Sigue siendo capturada — ConfigureAwait no afecta el flujo de excepciones
        _logger.LogError(ex, "Fetch failed");
        throw;
    }
}

public class WeatherApiClient
{
    private readonly HttpClient _http;
    private readonly ILogger<WeatherApiClient> _logger;
 
    public WeatherApiClient(HttpClient http, ILogger<WeatherApiClient> logger)
    {
        _http = http;
        _logger = logger;
    }
 
    public async Task<WeatherForecast?> GetForecastAsync(
        string city,
        CancellationToken cancellationToken = default)
    {
        // Código de biblioteca: ConfigureAwait(false) en cada await
        var url = $"/api/weather?city={Uri.EscapeDataString(city)}";
 
        using var response = await _http
            .GetAsync(url, cancellationToken)
            .ConfigureAwait(false);
 
        if (!response.IsSuccessStatusCode)
        {
            _logger.LogWarning("Weather API returned {StatusCode}", response.StatusCode);
            return null;
        }
 
        await using var stream = await response.Content
            .ReadAsStreamAsync(cancellationToken)
            .ConfigureAwait(false);
 
        return await JsonSerializer
            .DeserializeAsync<WeatherForecast>(stream, cancellationToken: cancellationToken)
            .ConfigureAwait(false);
    }
}

public class MainViewModel : INotifyPropertyChanged
{
    private string _status = string.Empty;
    public string Status
    {
        get => _status;
        set { _status = value; OnPropertyChanged(); }
    }
 
    public async Task LoadDataAsync()
    {
        // Await simple, deliberadamente: este método establece estado enlazado a la UI
        // después, así que debe volver al hilo de UI. Los ConfigureAwait(false) van
        // DENTRO de _apiClient (código de biblioteca) — la frontera entre "I/O sin
        // contexto" y "actualización de UI con contexto" es la frontera de la API,
        // no una línea de este método.
        var data = await _apiClient.GetForecastAsync("London");
 
        // Reanudado en el hilo de UI — seguro tocar estado enlazado
        Status = data?.Summary ?? "Sin datos";
    }
}

public class UserRepository
{
    private readonly AppDbContext _context;
 
    public UserRepository(AppDbContext context) => _context = context;
 
    public async Task<User?> GetByIdAsync(int id, CancellationToken ct = default)
    {
        // EF Core soporta ConfigureAwait(false) — seguro en código de biblioteca
        return await _context.Users
            .AsNoTracking()
            .FirstOrDefaultAsync(u => u.Id == id, ct)
            .ConfigureAwait(false);
    }
 
    public async Task<int> CreateUserAsync(User user, CancellationToken ct = default)
    {
        _context.Users.Add(user);
        await _context.SaveChangesAsync(ct).ConfigureAwait(false);
        return user.Id;
    }
}