System.Net.HttpListener en Windows 7 Ultimate x64 Limitado a 1k Conexiones Simultáneas

Question

He estado tratando de hacer algunas pruebas con el HTTP.sys/HttpListener en mi estación de trabajo y parece que hay algún límite en el lugar que previene más que 1000 conexiones concurrentes. ¿Alguien tiene más información sobre esto? (Como 1k parece un poco limpio para ser una coincidencia).

He intentado encontrar cualquier configuración de thread/config/registry, pero han aparecido vacíos.

Gracias de antemano.
GJ

---

Parece que salté la pistola un poco.

Parece que me he perdido al utilizar http.sys/HttpListener BeginGetContext no es muy bueno para las conexiones simultáneas, ya que el nuevo BeginGetContext solo se activará una vez que se haya cerrado la secuencia de respuesta de la solicitud anterior.

Por lo tanto, hay un retraso acumulado de 1000 solicitudes, y en este caso el retraso se estaba llenando.

De todos modos, si alguien tiene comentarios (o correcciones), no dude en ampliar.

Gracias
GJ

Answer 1

La forma en que he hecho que es tener un hilo que se escucha en el HttpListener utilizando el método de bloqueo GetContext() pero tan pronto como reciba una solicitud pasa fuera a otro hilo haciendo una invocación asíncrona utilizando el patrón y IAsyncResult Esto parece que funciona 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

Aquí es un enfoque simplista que soporta múltiples solicitudes simultáneas con HttpListener.

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

Esto ahora le permitirá recibir 50 solicitudes concurrentes. Debo admitir, ¡nunca he intentado crear 1000!