GetContextAsync() with Cancellation Support

Question

So I'm spinning up a HttpListener to wait for an OAuth2 response. In an ideal world, this is only going to be alive for a few seconds while the user logs in in the browser and we get posted the token.

I'd also like for this to have a CancellationToken so that the user can stop listening after a delay should they so wish.

My initial idea was to use something along the lines of:

_listener.Start();
Task<HttpListenerContext> t = _listener.GetContextAsync();            
while (!cancelled.IsCancellationRequested)
{
     if (t.IsCompleted)
     {
          break;
     }
     await Task.Run(() => Thread.Sleep(100));
}
HttpListenerContext ctx = t.Result;
//...
_listener.Stop();

But that doesn't sit right with me for so many reasons (weird async usage, polling, etc.).

So then I thought I might be able to use the synchronous version _listener.GetContext() in conjunction with Task.Run(func<T>, CancellationToken):

_listener.Start()
HttpListenerContext ctx = await Task.Run(() => _listener.GetContext(), cancelled);
//...
_listener.Stop();

This is a little better, the code's at least tidier, although it seems hacky using a synchronous version of the method asynchronously with a Task...

However this doesn't behave how I'd expect (aborting the running task when the token is cancelled).

This strikes me as something that really ought to be fairly simple to do so I assume I'm missing something.

So my question is thus... How do I listen asynchronously with a HttpListener in a cancellable fashion?

Answer 1

In net Core / Net 6 you can set a cancellationToken and/or a timeout through the WaitAsync() method.

await http.GetContextAsync().WaitAsync(cancelToken.Token);
await http.GetContextAsync().WaitAsync(TimeSpan.FromMinutes(1));
await http.GetContextAsync().WaitAsync(TimeSpan.FromMinutes(1),cancelToken.Token);

It will throw an exception when cancelled and/or when timed out.

Example:

var http = new HttpListener();
http.Prefixes.Add("http://+:80/");
http.Start();
CancellationTokenSource cancelToken = new CancellationTokenSource();
try {                
    var context = await http.GetContextAsync().WaitAsync(TimeSpan.FromMinutes(1) , cancelToken.Token);
} catch (TimeoutException ex) {
    Log("Timed out!");
} catch (TaskCanceledException ex) {
    Log("Cancelled!");
}

Answer 2

Because the GetContextAsync method does not support cancellation, it basically means that it is unlikely you can cancel the actual IO operation, yet unlikely to cancel the Task returned by the method, until you Abort or Stop the HttpListener. So the main focus here is always a hack that returns the control flow to your code.

While both the answers from @guru-stron and @peter-csala should do the trick, I just wanted to share another way without having to use Task.WhenAny.

You could wrap the task with a TaskCompletionSource like this:

public static class TaskExtensions
{
    public static Task<T> AsCancellable<T>(this Task<T> task, CancellationToken token)
    {
        if (!token.CanBeCanceled)
        {
            return task;
        }

        var tcs = new TaskCompletionSource<T>();
        // This cancels the returned task:
        // 1. If the token has been canceled, it cancels the TCS straightaway
        // 2. Otherwise, it attempts to cancel the TCS whenever
        //    the token indicates cancelled
        token.Register(() => tcs.TrySetCanceled(token), 
            useSynchronizationContext: false);

        task.ContinueWith(t =>
            {
                // Complete the TCS per task status
                // If the TCS has been cancelled, this continuation does nothing
                if (task.IsCanceled)
                {
                    tcs.TrySetCanceled();
                }
                else if (task.IsFaulted)
                {
                    tcs.TrySetException(t.Exception);
                }
                else
                {
                    tcs.TrySetResult(t.Result);
                }
            },
            CancellationToken.None,
            TaskContinuationOptions.ExecuteSynchronously,
            TaskScheduler.Default);

        return tcs.Task;
    }
}

And flow the control like this:

var cts = new CancellationTokenSource();
cts.CancelAfter(3000);

try
{
    var context = await listener.GetContextAsync().AsCancellable(cts.Token);
}
catch (TaskCanceledException)
{
    // ...
}