Implement a pricing endpoint that calls a slow dependency without allowing it to occupy the request indefinitely.

• Use HttpClientFactory.
• Link request cancellation to the operation timeout.
• Distinguish caller cancellation from timeout.
• Do not retry unsafe operations blindly.

I let the request token represent caller interest and add a narrower dependency deadline through a linked token. The exception filter distinguishes which cancellation fired, while normal downstream statuses remain explicit branches.

builder.Services.AddHttpClient<PricingClient>(client =>
{
    client.BaseAddress = new Uri(configuration["Pricing:BaseUrl"]!);
    client.Timeout = Timeout.InfiniteTimeSpan;
});

public sealed class PricingClient(HttpClient http)
{
    public async Task<PricingResult> GetAsync(Guid productId, CancellationToken requestCt)
    {
        using var deadline = CancellationTokenSource.CreateLinkedTokenSource(requestCt);
        deadline.CancelAfter(TimeSpan.FromSeconds(2));
        try {
            using var response = await http.GetAsync($"prices/{productId}",
                HttpCompletionOption.ResponseHeadersRead, deadline.Token);
            if (response.StatusCode == HttpStatusCode.NotFound) return PricingResult.NotFound;
            if (!response.IsSuccessStatusCode) return PricingResult.Unavailable;
            var price = await response.Content.ReadFromJsonAsync<PriceResponse>(
                cancellationToken: deadline.Token);
            return price is null ? PricingResult.Invalid : new PricingResult.Success(price);
        }
        catch (OperationCanceledException) when (!requestCt.IsCancellationRequested) {
            return PricingResult.TimedOut;
        }
        catch (HttpRequestException) {
            return PricingResult.Unavailable;
        }
        catch (Exception ex) when (ex is JsonException or NotSupportedException) {
            return PricingResult.Invalid;
        }
    }
}

app.MapGet("/products/{id:guid}/price", async (Guid id, PricingClient client,
    CancellationToken ct) => (await client.GetAsync(id, ct)).ToHttpResult());

A finite dependency budget protects request capacity while caller cancellation avoids wasted work. Retries, if added, must fit inside the same overall deadline and target only transient, safe operations.

• The caller cancels first.
• Timeout and response complete together.
• The dependency returns malformed JSON.
• DNS or connection setup fails.

• Use a fake handler that never completes.
• Cancel the request token separately.
• Assert 504 wording contains no downstream body.
• Verify response disposal.

• Setting only a large global HttpClient timeout.
• Turning every cancellation into 504.
• Reading the whole response before checking status.
• Retrying without an overall deadline.