C#

public void StartListen()
{
     IAsyncResult result;
     _Server.Start();
     while (true)
     {
        result = _Server.BeginGetContext(new AsyncCallback(this.HttpCallback), _Server);
        result.AsyncWaitHandle.WaitOne();
     }
}

George_George wrote:

When I call EndGetContext, the server is able to process another request

N a v a n e e t h wrote:

Looks like you need to refactor this. Consider a design where each request will have it's own IAsyncResult instance. I guess that should solve the problem

George_George wrote:

Do you mean the pattern in my code is not truly handles incoming requests at the same time?

George_George wrote:

Are there any benefits doing this? Could you show me a couple of lines of pseudo code please?

George_George wrote:

When will the event which WaitOne is wait on be signalled?

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using System.Net;
using System.Threading;

namespace TestServiceStop1
{
    public partial class Service1 : ServiceBase
    {
        private Thread _tHttpThread;
        private TestHttpServer _server;

        public Service1()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            _server = new TestHttpServer(this);

            _tHttpThread = new Thread(_server.StartListen);

            _tHttpThread.Start();
        }

        protected override void OnStop()
        {
            // stop HTTP server
            _server.Stop(false);
        }
    }

    public class TestHttpServer
    {
        // listening HTTP port
        private int _Port = 0;

        // internal wrapped HTTP listener
        private HttpListener _Server = new HttpListener();

        private Service1 _manager;

        public TestHttpServer (Service1 manager)
        {
            _manager = manager;
        }

        public int ListenPort
        {
            get
            {
                return _Port;
            }
            set
            {
                _Port = value;
            }
        }

        public void StartListen()
        {
            try
            {

                _Server.Prefixes.Add(String.Format("http://+:{0}/", 9099));
                _Server.Start();
                while (true)
                {
									_Server.BeginGetContext(new AsyncCallback(this.HttpCallback), _Server);
                }
            }
            // any exceptions are not expected
            // catch InvalidOperationException during service stop
            // [System.InvalidOperationException] = {"Please call the Start() method before calling this method."}
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void Stop(bool isTerminate)
        {
            _Server.Stop();
        }

        // callback function when there is HTTP request received
        private void HttpCallback(IAsyncResult result)
        {
            HttpListenerContext context = _Server.EndGetContext(result);
            HandleRequest(context);
        }

        // find matched URL HTTP request handler and invoke related handler
        private void HandleRequest(HttpListenerContext context)
        {
            string matchUrl = context.Request.Url.AbsolutePath.Trim().ToLower();

            context.Response.StatusCode = 200;
            context.Response.StatusDescription = "OK";
            context.Response.Close();
        }
    } // end of Http Listener class
}

George_George wrote:

while (true)
{
result = _Server.BeginGetContext(new AsyncCallback(this.HttpCallback), _Server);
result.AsyncWaitHandle.WaitOne();
}

_Server.BeginGetContext(new AsyncCallback(this.HttpCallback), _Server);

while (true)
                {
                    try
                    {
                        result = _Server.BeginGetContext(new AsyncCallback(this.HttpCallback), _Server);
                        result.AsyncWaitHandle.WaitOne();
                    }catch (HttpListenerException) { break; }
                    catch  (InvalidOperationException)  {  break;  }
                    
                }

George_George wrote:

catch (Exception ex)
{
throw ex;
}

throw;

humdumof wrote:

We declare an array as

int arr[] = new int[5]; // <---a