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

Question

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

J'ai essayé de trouver un fil / config / paramètre du registre, mais ont mis au point vide.

Merci à l'avance.
GJ

---

On dirait que j'ai sauté le pistolet un peu.

Il me semble avoir manqué qu'utiliser http.sys / HttpListener BeginGetContext est pas très bon pour les connexions simultanées que le nouveau BeginGetContext ne le feu après que le flux de réponse de la demande préalable a fermé.

Donc, il y a un arriéré de 1000 demandes, et dans ce cas, le carnet de commandes se remplissait.

Quoi qu'il en soit - si quelqu'un a des commentaires (ou des corrections probables) ne 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 async Invoke en utilisant le modèle de IAsyncResult et ce semble fonctionner très bien.

    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 vous permettra désormais de recevoir 50 demandes simultanées. Je dois admettre que je ne l'ai jamais essayé de créer 1000!