C# HttpListener handling requests with multiple threads

Question

I have to apply for 2 approches:

1. handle each HTTP request with a different thread/task.
2. finish the requests gracefully when the cancellation token invoked.

Now, I have a problem that when the cancellation token invoked and a request doesn't arrive - I stack in the "server.getContext" blocking area. Any idea how can I solve it?

public void Listen()
{
  CancellationTokenSource source = new CancellationTokenSource();
  CancellationToken token = source.Token;
  server.Start();
  Console.WriteLine($"Waiting for connections on {url}");
  HandleShutdownWhenKeyPressed(source);
  HandleIncomingHTTPRequests(token);
  server.Close();
}

void HandleIncomingHTTPRequests(CancellationToken token)
{
  while (!token.IsCancellationRequested)
  {
    HttpListenerContext ctx = server.GetContext();
    // I stack here until the request has arrived even if the cancellation token has invoked.
    Task.Run(() =>
    {
      HttpListenerRequest req = ctx.Request;
      HttpListenerResponse res = ctx.Response;
      // SOME STUFF ....
    },token)
  }
 }

Thanks in advance.

Answer 1

You don't need Task.Run, and the beauty of async IO is that you don't need to handle Thread,ThreadPool or Task.Run yourself: IO completion is already handled for you by the actual implementation (in this case, HttpListener, but in other cases it could be FileStream, Socket, etc).

All you need is this:

public static async Task RunHttpListenerAsync( HttpListener listener, CancellationToken ct )
{
    listener.Start();

    while( !ct.IsCancellationRequested )
    {
        HttpListenerContext ctx = await listener.GetContextAsync().ConfigureAwait(false);
        
        try
        {
            await ProcessRequestAsync( ctx ).ConfigureAwait(false);
        }
        catch( Exception ex )
        {
            // TODO: Log `ex`.
        }
    }
}

private static async Task ProcessRequestAsync( HttpListenerContext ctx )
{
    HttpListenerRequest  req = ctx.Request;
    HttpListenerResponse res = ctx.Response;

    // do stuff
}

Provided your program runs without a synchronization context that requires resumption on a single thread (i.e. you aren't running inside WinForms or WPF) - or - you use .ConfigureAwait(false) everywhere (like you should) then every time your program yields to the scheduler it will resume on whatever background thread in the thread-pool it wants, including any available threads that would resume the current Task concurrently.