System.Net.HttpListener su Windows 7 Ultimate x64 limitata a 1K connessioni simultanee

Question

Ho cercato di fare qualche test con la HTTP.sys / HttpListener sulla mia workstation e sembra che ci sia qualche limite in vigore che impedisce più di 1000 connessioni simultanee. Qualcuno ha qualche ulteriori informazioni su questo? (Come 1k sembra un po 'di pulito per essere una coincidenza).

ho cercato di trovare un filo / config / registro impostazione, ma hanno creato vuoti.

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 connessioni simultanee come il nuovo BeginGetContext sarà solo il fuoco dopo che il flusso di risposta dalla richiesta preventiva ha chiuso.

Quindi non v'è un arretrato di 1000 richieste, e in questo caso l'arretrato si stava riempiendo.

In ogni caso - se qualcuno ha qualche commenti (o correzioni probabile) non esitate a espandere

.

Grazie
GJ

Answer 1

Il modo in cui l'ho fatto è quello di avere un filo che ascolti sul HttpListener utilizzando il metodo GetContext() blocco ma non appena riceve una richiesta passa a un altro filo facendo un'asincrona invoke 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);
        }

Questa ora vi permetterà di ricevere 50 richieste simultanee. Devo ammettere, non ho mai cercato di creare 1000!