System.Net.HttpListener su Windows 7 Ultimate x64 Limitato a 1k di connessioni simultanee

Question

Ho provato a eseguire alcuni test con HTTP.sys/HttpListener sulla mia workstation e sembra che ci sia un limite in atto che impedisce più che 1000 connessioni simultanee. Qualcuno ha ulteriori informazioni su questo? (Come 1k sembra un po 'da pulire per essere una coincidenza).

Ho provato a trovare qualsiasi impostazione di thread/config/registro, ma sono venuti a vuoto.

Grazie in anticipo.
GJ

---

Sembra che ho saltato la pistola un po '.

mi sembra di aver perso che l'uso di http.sys/HttpListener BeginGetContext non è molto buona per le connessioni simultanee come il nuovo BeginGetContext sarà solo il fuoco dopo che il flusso di risposta dalla richiesta preventiva ha chiuso.

Quindi c'è un arretrato di 1000 richieste e in questo caso il backlog si stava riempiendo.

In ogni caso, se qualcuno ha commenti (o correzioni probabili) si senta libero di espandersi.

Grazie
GJ

Answer 1

Il modo in cui l'ho fatto è quello di avere un filo che ascolta sul HttpListener utilizzando il metodo di blocco GetContext() ma non appena riceve una richiesta passa a un altro filo facendo un'invoke asincrono utilizzando il modello IAsyncResult e questo sembra funzionare bene.

private void Run() 
    { 
     while (true) 
     { 
      if (this._disposed || this._shouldTerminate) return; 

      if (this._listener.IsListening) 
      { 
       try 
       { 
        HttpListenerContext context = this._listener.GetContext(); 

        //Hand it off to be processed asynchronously 
        this._delegate.BeginInvoke(context, new AsyncCallback(this.EndRequest), null); 
       } 
       catch (Exception ex) 
       { 
        this.LogErrors(ex); 
       } 
      } 
     } 
    } 

    private delegate HttpServerContext HandleRequestDelegate(HttpListenerContext context); 

    private HttpServerContext HandleRequest(HttpListenerContext context) 
    { 
     IHttpListenerHandler handler; 
     HttpServerContext serverContext = new HttpServerContext(this, context); 
     try 
     { 
      bool skipHandling = this.ApplyPreRequestModules(serverContext); 
      if (!skipHandling) 
      { 
       handler = this._handlers.GetHandler(serverContext); 
       handler.ProcessRequest(serverContext); 
      } 
     } 
     catch (NoHandlerException noHandlerEx) 
     { 
      this.LogErrors(noHandlerEx); 
      context.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed; 
     } 
     catch (HttpServerException serverEx) 
     { 
      this.LogErrors(serverEx); 
      context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; 
     } 

     return serverContext; 
    } 

    private void EndRequest(IAsyncResult result) 
    { 
     try 
     { 
      HttpServerContext context = this._delegate.EndInvoke(result); 
      this.ApplyPreResponseModules(context); 
      context.Response.Close(); 
     } 
     catch (Exception ex) 
     { 
      this.LogErrors(ex); 
     } 
    } 

Answer 2

Ecco un approccio semplicistico supportare richieste multiple simultanee con HttpListener.

 for (int i = 0; i < 50; i++) { 
      _listener.BeginGetContext(GetContextCallback, null); 
     } 

Questo ora consente di ricevere 50 richieste simultanee. Devo ammettere, non ho mai provato a creare 1000!