public static void AddPrefix(string uriPrefix, HttpListener httpListener)
 {
     lock (((ICollection) _ipToEndpoints).SyncRoot)
     {
         addPrefix (uriPrefix, httpListener);
     }
 }

 public static void AddPrefix(string prefix, HttpListener listener)
 {
     lock (_ipToEndpoints)
     {
         AddPrefixInternal(prefix, listener);
     }
 }

    private static EndPointListener getEndPointListener (
      IPAddress address, int port, HttpListener httpListener, bool secure)
    {
      Dictionary<int, EndPointListener> endpoints = null;
      if (_ipToEndpoints.ContainsKey (address)) {
        endpoints = _ipToEndpoints [address];
      }
      else {
        endpoints = new Dictionary<int, EndPointListener> ();
        _ipToEndpoints [address] = endpoints;
      }

      EndPointListener epListener = null;
      if (endpoints.ContainsKey (port)) {
        epListener = endpoints [port];
      }
      else {
        epListener = new EndPointListener (
          address,
          port,
          secure,
          httpListener.CertificateFolderPath,
          httpListener.DefaultCertificate);

        endpoints [port] = epListener;
      }

      return epListener;
    }

 void Awake()
 {
     listener = new HttpListener();
     listener.Prefixes.Add("http://*:7663/");
     listener.Start();
     listener.BeginGetContext(new AsyncCallback(ListenerCallback), listener);
 }

 static void StartListener()
 {
     listener = new HttpListener();
     listener.Prefixes.Add("http://localhost:57789/");
     listener.Start();
     listener.BeginGetContext(ListenerCallback, listener);
 }

    private void ListenThread()
    {
        try
        {
            listener = new HttpListener();

            foreach (string prefix in prefixes)
            {
                listener.Prefixes.Add(prefix);
            }

            listener.Start();

            while (true)
            {
                HttpListenerContext context = listener.GetContext();

                Debug.LogFormat("Recieved request from {0}.", context.Request.RemoteEndPoint.ToString());

                context.Response.StatusCode = 200;

                lock (waitingContexts)
                {
                    waitingContexts.AddLast(context);
                }
            }
        }
        catch(Exception e)
        {
            Debug.LogErrorFormat("Web server error at {0}.", e.Source);
            Debug.LogError(e.Message, this);
        }
    }

        private ArrayList _unhandled; // List<ListenerPrefix> unhandled; host = '*'

        #endregion Fields

        #region Constructors

        public EndPointListener(HttpListener listener, IPAddress addr, int port, bool secure)
        {
            Listener = listener;

            if (secure)
            {
            #if SSL
                this.secure = secure;
                cert = listener.LoadCertificateAndKey (addr, port);
            #else
                throw new Exception("SSL is not supported");
            #endif
            }

            _endpoint = new IPEndPoint(addr, port);
            _sock = new Socket(addr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            _sock.Bind(_endpoint);
            _sock.Listen(500);
            var args = new SocketAsyncEventArgs {UserToken = this};
            args.Completed += OnAccept;
            Socket dummy = null;
            Accept(_sock, args, ref dummy);
            _prefixes = new Hashtable();
            _unregistered = new Dictionary<HttpConnection, HttpConnection>();
        }

    static void Main()
    {
        Console.Title = "Samples.CustomChecks.3rdPartySystem";
        Console.WriteLine("Press enter key to toggle the server to return a error or success");
        Console.WriteLine("Press any key to exit");

        using (listener = new HttpListener())
        {
            listener.Prefixes.Add("http://localhost:57789/");
            listener.Start();
            listener.BeginGetContext(ListenerCallback, listener);

            while (true)
            {
                ConsoleKeyInfo key = Console.ReadKey();
                Console.WriteLine();

                if (key.Key != ConsoleKey.Enter)
                {
                    return;
                }
                listener.Close();
                if (isReturningOk)
                {
                    Console.WriteLine("\r\nCurrently returning success");
                }
                else
                {
                    Console.WriteLine("\r\nCurrently returning error");
                }
                isReturningOk = !isReturningOk;
            }
        }
    }

 public static void AddPrefix(ILogger logger, string prefix, HttpListener listener)
 {
     lock (ip_to_endpoints)
     {
         AddPrefixInternal(logger, prefix, listener);
     }
 }

        public static void AddListener(HttpListener listener)
        {
            ArrayList added = new ArrayList();

            try
            {
                lock (ip_to_endpoints)
                {
                    foreach (string prefix in listener.Prefixes)
                    {
                        AddPrefixInternal(prefix, listener);

                        added.Add(prefix);
                    }
                }
            }
            catch
            {
                foreach (string prefix in added)
                {
                    RemovePrefix(prefix, listener);
                }

                throw;
            }
        }

 public void FixtureSetup()
 {
     _listener = new HttpListener(_uri.OriginalString);
     _listener.Start();
     _server = new Tracker();
     _server.RegisterListener(_listener);
     _listener.Start();
 }

        public Server()
        {
            this.httpListener = new HttpListener();

            this.httpListener.Prefixes.Add("http://localhost:8080/");
            this.httpListener.Prefixes.Add("http://127.0.0.1:8080/");
            this.httpListener.Prefixes.Add("http://test.localhost:8080/");
        }

	public Listener ()
	{
		EndPoints = new List<IPEndPoint> ();

		listener = new HttpListener ();
		listener.Prefixes.Add (KeepAliveTest.URL);
		listener.Start ();
		listener.BeginGetContext (Handle, null);
	}

  public void Configure(string[] prefixes, string vdir, string pdir)
  {
    _virtualDir = vdir;
    _physicalDir = pdir;
    _listener = new HttpListener();

    foreach (string prefix in prefixes)
      _listener.Prefixes.Add(prefix);
  }

 /// <summary>
 /// Create an instance of <see cref="WebAppServer"/>.
 /// </summary>
 /// <param name="urlReservation">
 /// The URL reservation to listen on. This string is similar to a URL, but the
 /// hostname may be a strong wildcard ('+') or a weak wildcard ('*'). E.g. "http://+:8080/".
 /// </param>
 public WebAppServer(string urlReservation)
 {
     _urlRegex = new Regex("^" + urlReservation.Replace("*", ".*?").Replace("+", ".*?"), RegexOptions.IgnoreCase);
     _listener = new HttpListener();
     _listener.Prefixes.Add(urlReservation);
     _disconnectHandler = new DisconnectHandler(_listener);
     var uri = new Uri(urlReservation.Replace("*", "localhost").Replace("+", "localhost"));
     _webAppConfiguration = new WebAppConfiguration(uri);
     StaticFiles = new StaticFileSpecCollection();
 }

 public static void RemoveListener(ILogger logger, HttpListener listener)
 {
     lock (ip_to_endpoints)
     {
         foreach (string prefix in listener.Prefixes)
         {
             RemovePrefixInternal(logger, prefix, listener);
         }
     }
 }

        public HttpListener CreateListener(List<string> addresses)
        {
            var listener = new HttpListener();

            addresses.ForEach(a => listener.Prefixes.Add(a));

            listener.Start();

            return listener;
        }

 public Server(string prefix)
 {
     if (!HttpListener.IsSupported)
     {
         Console.WriteLine("server is not supported");
     }
     listener = new HttpListener();
     listener.Prefixes.Add(prefix);
     resourceLocator = new HttpResourceLocator();
 }

        public NetEventHandler()
        {
            BaseUrl = Net.GetUrl(Net.GetIp(IPType.All), Net.FindPort(), "").ToString();
            ServicePointManager.DefaultConnectionLimit = 100;
            _httpListener = new HttpListener();
            _httpListener.Prefixes.Add(BaseUrl);

            _httpListener.Start();
            ThreadPool.QueueUserWorkItem(Listen);
        }

		public ListenerScope (Action<HttpListenerContext> processor)
		{
			this.processor = processor;

			this.listener = new HttpListener ();
			this.listener.Prefixes.Add ("http://*:8001/");
			this.listener.AuthenticationSchemes = AuthenticationSchemes.Anonymous;
			this.listener.Start ();

			this.listener.BeginGetContext (this.RequestHandler, null);
		}