Implement a search endpoint whose EF Core work stops when the request is cancelled.

• Keep the result bounded and projected.
• Pass the same token to EF Core materialization.
• Treat OperationCanceledException as expected when the request token is cancelled.
• Do not claim cancellation reverses committed writes.

I accept the request token at the endpoint and pass it all the way to ToListAsync. Cancellation reduces waste, but query shape, indexes, and timeouts still matter. For a read, abandoning work is usually straightforward; for writes, cancellation can leave commit outcome uncertain and needs idempotency or reconciliation.

[HttpGet("customers/search")]
public async Task<ActionResult<IReadOnlyList<CustomerSearchItem>>> SearchCustomers(
    [FromQuery] string prefix,
    CancellationToken cancellationToken)
{
    var normalized = prefix.Trim();
    if (normalized.Length < 2)
        return BadRequest("Enter at least two characters.");

    var customers = await db.Customers
        .AsNoTracking()
        .Where(customer => customer.Name.StartsWith(normalized))
        .OrderBy(customer => customer.Name)
        .ThenBy(customer => customer.Id)
        .Select(customer => new CustomerSearchItem(
            customer.Id,
            customer.Name))
        .Take(50)
        .ToListAsync(cancellationToken);

    return Ok(customers);
}

The provider receives one bounded query and a cancellation token for the asynchronous command. Whether cancellation is immediate depends on provider and database support. Track cancelled dependency calls separately from genuine failures so normal client disconnects do not create noisy error alerts.

• The client disconnects before the query starts or during execution.
• The prefix is too short or whitespace.
• Many customers share the same name.
• The database provider cannot cancel instantly.

• Cancel a test token during an isolated integration query.
• Verify the token reaches the EF async method.
• Assert the query remains capped at 50.
• Check cancellation telemetry is not counted as an application fault.

• Accepting a token but never passing it to EF Core.
• Using synchronous materialization inside an async endpoint.
• Treating every cancellation as a server error.
• Using cancellation as a substitute for indexes and bounded queries.