System.Net.HttpListener sur Windows 7 Ultimate x64 limité à 1k connexions simultanées

Question

J'ai essayé de faire des tests avec le HTTP.sys/HttpListener sur mon poste de travail et il semble qu'il y ait une limite en place qui empêche plus que 1000 connexions simultanées. Quelqu'un at-il plus d'informations à ce sujet? (Comme 1k semble un peu propre à être une coïncidence).

J'ai essayé de trouver n'importe quel paramètre de thread/config/registry, mais j'ai trouvé vide.

Merci d'avance.
GJ

---

On dirait que j'ai sauté le pistolet un peu. Il semble que j'ai manqué l'utilisation de http.sys/HttpListener BeginGetContext n'est pas très bon pour les connexions simultanées car le nouveau BeginGetContext ne se déclenchera que lorsque le flux de réponse de la demande précédente aura été fermé. Il y a donc un arriéré de 1 000 demandes, et dans ce cas, l'arriéré se remplissait.

De toute façon - si quelqu'un a des commentaires (ou des corrections probables), n'hésitez pas à développer.

Merci
GJ

Answer 1

La façon dont je l'ai fait est d'avoir un fil qui écoute sur le HttpListener en utilisant la méthode GetContext() de blocage, mais dès qu'il reçoit une demande, il passe à un autre fil en faisant un Invoke async en utilisant le modèle IAsyncResult et Cela semble fonctionner correctement.

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

Voici une approche simpliste de soutenir plusieurs requêtes simultanées avec HttpListener.

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

Cela va maintenant vous permettre de recevoir 50 demandes simultanées. Doit admettre, je n'ai jamais essayé de créer 1000!