Cancellation and Timeouts

public static class Demo
{
    public static async Task<bool> CancelRequest()
    {
        using var source = new System.Threading.CancellationTokenSource();
        Task work = Task.Delay(System.Threading.Timeout.Infinite, source.Token);
        source.Cancel();
        try { await work; }
        catch (OperationCanceledException) when (source.IsCancellationRequested)
        {
            return true;
        }
        return false;
    }

    public static async Task<bool> StopWaitingAndCleanUp()
    {
        using var source = new System.Threading.CancellationTokenSource();
        Task work = Task.Delay(System.Threading.Timeout.Infinite, source.Token);
        bool timedOut = false;
        try { await work.WaitAsync(TimeSpan.FromMilliseconds(5)); }
        catch (TimeoutException) { timedOut = true; }
        finally
        {
            source.Cancel();
            try { await work; }
            catch (OperationCanceledException) when (source.IsCancellationRequested) { }
        }
        return timedOut;
    }
}

CancelRequest supplies a token to an operation that observes it. StopWaitingAndCleanUp first limits the caller’s wait using WaitAsync. That timeout does not cancel the original task; the finally block requests cancellation and then observes the task’s completion. 2

An operation that ignores its token may not finish promptly. This cleanup is bounded by the behavior of Task.Delay, not a universal guarantee for arbitrary work.

import asyncio


async def cancel_request():
    started = asyncio.Event()
    cleaned = asyncio.Event()

    async def work():
        try:
            started.set()
            await asyncio.Event().wait()
        finally:
            cleaned.set()

    task = asyncio.create_task(work())
    await started.wait()
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        pass
    return cleaned.is_set()


async def stop_waiting_and_clean_up():
    cleaned = False
    try:
        async with asyncio.timeout(0.005):
            try:
                await asyncio.Event().wait()
            finally:
                cleaned = True
    except TimeoutError:
        return cleaned
    return False

task.cancel() requests cancellation; awaiting the task lets its finally block run. The timeout context cancels its enclosed waiting operation and converts its own cancellation into TimeoutError outside the context. Do not routinely swallow CancelledError inside worker code; doing so can defeat task-group and timeout behavior. 3