protected ApiClient(ApiKeyConnection connection)
        {
            Ensure.ArgumentNotNull(connection, nameof(connection));

            ApiKeyConnection = connection;
            HttpConnection = new HttpConnection(ApiKeyConnection);
        }

 IObservable<HttpConnection> GetConnection(Uri uri)
 {
     if(m_connection!= null 
         && m_connection.Uri.Host==uri.Host 
         && m_connection.Uri.Port==uri.Port
         && m_connection.IsConnected
         )
     {
         return Observable.Return(m_connection)
             .Do(x =>
             {
                 Console.WriteLine("<KeepAlive>");
             })
             ;
     }
     else
     {
         return HttpConnection.Create(uri).Connect()
             .Do(x => {
                 m_connection = x;
                 Console.WriteLine(x);
             })
             ;
     }
 }

 public void SendMessageSendsAndReceivesAMessage()
 {
     var action = "DoSomething";
     var request = new ServerRequest
     {
         ServerName = "TestServer"
     };
     var url = "http://somewhere/";
     var factory = new TestClientFactory((u, a, d) =>
     {
         Assert.AreEqual(url + "server/TestServer/RawXmlMessage.aspx", u.AbsoluteUri);
         Assert.AreEqual("POST", a);
         Assert.AreEqual(action, d["action"]);
         Assert.AreEqual(request.ToString(), d["message"]);
         var theResponse = new Response
         {
             RequestIdentifier = request.Identifier
         };
         return Encoding.UTF8.GetBytes(theResponse.ToString());
     });
     var connection = new HttpConnection(new Uri(url), factory);
     var response = connection.SendMessage(action, request);
     Assert.IsInstanceOf<Response>(response);
     Assert.AreEqual(request.Identifier, response.RequestIdentifier);
 }

 internal HttpListenerContext(HttpConnection cnc, ILogger logger)
 {
     this.cnc = cnc;
     _logger = logger;
     request = new HttpListenerRequest(this);
     response = new HttpListenerResponse(this, _logger);
 }

        public void Setup()
        {
            requestedUrl.Clear();
            partialData = false;
            int i;
            for (i = 0; i < 1000; i++)
            {
                try
                {
                    listener = new HttpListener();
                    listener.Prefixes.Add(string.Format(listenerURL, i));
                    listener.Start();
                    break;
                }
                catch
                {

                }
            }
            listener.BeginGetContext(GotContext, null);
            rig = TestRig.CreateMultiFile();
            connection = new HttpConnection(new Uri(string.Format(listenerURL, i)));
            connection.Manager = rig.Manager;

            id = new PeerId(new Peer("this is my id", connection.Uri), rig.Manager);
            id.Connection = connection;
            id.IsChoking = false;
            id.AmInterested = true;
            id.BitField.SetAll(true);
            id.MaxPendingRequests = numberOfPieces;
            
            requests = rig.Manager.PieceManager.Picker.PickPiece(id, new List<PeerId>(), numberOfPieces);
        }

		internal HttpListenerContext (HttpConnection cnc)
		{
			this.cnc   = cnc;
			err_status = 400;
			request    = new HttpListenerRequest (this);
			response   = new HttpListenerResponse (this);
		}

 public void RemoveConnection(HttpConnection connection)
 {
     lock (this._requests)
     {
         this._requests.Remove(connection);
     }
 }

 public void ExecuteTest()
 {
     HttpConnection target = new HttpConnection();
     HttpWebRequest httpRequest = GetHttpWebRequest();
     string actual = target.Execute(payLoad, httpRequest);
     Assert.IsNotNull(actual);
 }

        public Client(HttpConnection connection)
        {
            _nodeName = Environment.GetEnvironmentVariable("CONSUL_CLIENT_NODE_NAME") ?? "undefined node";
            _serviceName = Environment.GetEnvironmentVariable("CONSUL_CLIENT_SERVICE_NAME") ?? "undefined service";
            _datacenterName = Environment.GetEnvironmentVariable("CONSUL_CLIENT_DATACENTER_NAME") ?? "dc1";

            _catalog = new Catalog(connection);
        }

//		private bool _headersSent;

		/// <summary>
		/// Initializes a new instance of the AspWorkerRequest class
		/// </summary>
		/// <param name="connection"></param>
		/// <param name="request"></param>
		public AspWorkerRequest(AspHost aspHost, HttpConnection connection, HttpRequest request) : base(string.Empty, string.Empty, null)
		{						
			_aspHost = aspHost;
			_connection = connection;
			_request = request;
			_response = new HttpResponse(new OkStatus());

			this.ParsePathInfo();
		}

		/// <summary>
		/// Initializes a new instance of the AddressBookItemConnectionManager class
		/// </summary>
		/// <param name="item">The address book item that defines the remote host to connect to</param>
		/// <param name="connection">The Tcp connection that will be used throughout the lifetime of the connection</param>
		public AddressBookItemConnectionManager(AddressBookItem item, HttpConnection connection)
		{
			if (item == null)
				throw new ArgumentNullException("item");

			if (connection == null)
				throw new ArgumentNullException("connection");

			_propertyBag = new Hashtable();
			_item = item;
			_connection = connection;
			_connection.Opened += new HttpConnectionEventHandler(OnInternalConnectionOpened);
			_connection.Closed += new HttpConnectionEventHandler(OnInternalConnectionClosed);
			_connection.Exception += new ExceptionEventHandler(OnInternalConnectionException);
		}      

        public NanoHttpRequest(HttpConnection conn, string request)
        {
            Connection = conn;
            if (string.IsNullOrEmpty(request))
            {
                Invalid = true;
                return;
            }

            var fls = request.Split(new char[]{ ' ' }, 3);

            if (fls.Length < 2)
            {
                Invalid = true;
                return;
            }

            Method = fls[0];
            Address = fls[1];

            //if (Method == "POST")
            {
                var heco = request.Split(new string[]{ "\r\n\r\n" }, 2, StringSplitOptions.None);

                if (heco.Length < 2)
                {
                    Invalid = true;
                    return;
                }

                var he = heco[0];
                var co = heco[1];
                Content = co;
                var lines = he.Split(new string[]{ "\r\n", "\n" }, StringSplitOptions.None);

                for (int i = 1; i < lines.Length; i++)
                {
                    var hl = lines[i].Split(new String[]{": "}, 2, StringSplitOptions.None);
                    if (hl.Length < 2) continue;
                    Headers[hl[0]] = hl[1];
                }
            }
        }

        public void RequestTimeout(HttpConnection connection)
        {
            var param = connection.Param;
            int msgId = param.Get("MsgId").ToInt();
            int actionId = param.Get("ActionId").ToInt();
            int errorCode = LanguageHelper.GetLang().ErrorCode;
            string errorMsg = LanguageHelper.GetLang().RequestTimeout;
            var head = new MessageHead(msgId, actionId, "st", errorCode, errorMsg);
            head.HasGzip = true;
            var ms = new MessageStructure();
            ms.WriteBuffer(head);
            byte[] data = ms.ReadBuffer();

            string remoteAddress = connection.Context.Request.RemoteEndPoint.Address.ToString();
            string successMsg = string.Format("{0}>>发送超时到{1} {2}字节！",
                                              DateTime.Now.ToString("HH:mm:ss:ms"), remoteAddress, data.Length);
            Console.WriteLine(successMsg);
            OnResponseCompleted(connection, data);
        }

        private void Process(HttpConnection connection, NanoHttpRequest request)
        {
            if (request.Address == "/")
            {
                connection.Response(_root.Handle(request));
                return;
            }

            var endpoint = request.Address.Split(new char[]{'/'}, StringSplitOptions.RemoveEmptyEntries)[0];

            if (_handlers.ContainsKey(endpoint))
            {
                connection.Response(_handlers[endpoint].Handle(request));
            }

            else
            {
                connection.Response(new ErrorHandler(StatusCode.BadRequest, "Unknown endpoint: " + endpoint).Handle(request));
            }
        }

        protected override void Run()
        {
            this._listener.Start();
            while (true)
            {
                try
                {
                    TcpClient client = this._listener.AcceptTcpClient();
                    HttpConnection connection = new HttpConnection(this, client);
                    lock (this._requests)
                    {
                        this._requests.Add(connection);
                    }
                    connection.Start();

                }
                catch {
                
                }
            }
            
        }

        public virtual void OnAccept( IAsyncResult ar )
        {
            try
            {
                Socket newSocket = listenSocket.EndAccept( ar );

                if ( newSocket != null )
                {
                    HttpConnection newClient = new HttpConnection( newSocket, new RemoveClientDelegate( this.RemoveClient ) );
                    clients.Add( newClient );
                    newClient.Start();
                }
            }
            catch {}
            try
            {
                listenSocket.BeginAccept( new AsyncCallback( this.OnAccept ), listenSocket );
            }
            catch
            {
                Dispose();
            }
        }

        public void Request(HttpConnection connection, string clientAddress, byte[] data)
        {
            string paramString = string.Empty;
            try
            {
                paramString = Encoding.ASCII.GetString(data);
                PacketMessage packet = ParsePacketMessage(clientAddress, paramString, ConnectType.Http);
                packet.Head.SSID = connection.SSID.ToString("N");
                HttpConnectionManager.Push(connection);

                if (ReceiveCompleted != null)
                {
                    //分发送到游戏服
                    byte[] packData = packet.ToByte();
                    string successMsg = string.Format("{0}>>{1}接收到{2}字节！",
                        DateTime.Now.ToString("HH:mm:ss:ms"), clientAddress, data.Length);
                    ReceiveCompleted.BeginInvoke(clientAddress, packData, OnReceiveCompleted, successMsg);
                }
            }
            catch (Exception ex)
            {
                TraceLog.WriteError("Receive form http request:{0} error:{1}", paramString, ex);
            }
        }

        internal HttpRequest(IPEndPoint client, string method, string path, string protocol, string version, NameValueCollection headers, byte[] postData, HttpConnection connection)
        {
            m_connection = connection;

            Client = client;
            Method = method;

            var pathDelim = path.IndexOf('?');
            if (pathDelim == -1)
            {
                Path = HttpUtility.UrlDecode(path);
                QueryString = new NameValueCollection();
            }
            else
            {
                Path = HttpUtility.UrlDecode(path.Substring(0, pathDelim));
                QueryString = HttpUtility.ParseQueryString(path.Substring(pathDelim + 1));
            }

            Protocol = protocol;
            Version = version;
            Headers = headers;
            PostData = postData;
        }

 public HttpSecureConnectionState(HttpConnection connection, Action<HttpConnection> callback)
 {
     Connection = connection;
     Callback = callback;
 }

		/// <summary>
		/// Runs the background thread that listens for incoming connections
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnThreadRun(object sender, BackgroundThreadStartEventArgs e)
		{
			try
			{
				IPEndPoint ep = (IPEndPoint)e.Args[0];
            
				Debug.Assert(ep != null);
				Trace.WriteLineIf(_verbose, string.Format("Binding to the end point '{0}'.", ep.ToString()), TraceCategory);
                  
				_listeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
				_listeningSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
				_listeningSocket.Bind(ep);
            
				Trace.WriteLineIf(_verbose, string.Format("Listening for inbound connections on '{0}'.", ep.ToString()), TraceCategory);

				while(true)
				{           
					_listeningSocket.Listen(100); // pending connections queue length

					// accept the connection
					Socket socket = _listeningSocket.Accept();
      
					Trace.WriteLineIf(_verbose, string.Format("Accepted an inbound connection from '{0}'.", socket.RemoteEndPoint.ToString()), TraceCategory);

					// create a new connection for the connection
					HttpConnection connection = new HttpConnection(socket, _verbose);
					connection.RequestDispatcher = _dispatcher;
					connection.Exception += new EventHandler<ExceptionEventArgs>(this.OnConnectionException);
					connection.Opened += new EventHandler<HttpConnectionEventArgs>(this.OnConnectionOpened);
                    connection.Closed += new EventHandler<HttpConnectionEventArgs>(this.OnConnectionClosed); 
					connection.IsServerSideConnection = true;
					connection.BeginSession(true);                                       
				}  
			}
			catch(ThreadAbortException)
			{
			}
			catch(Exception ex)
			{
				this.OnException(this, new ExceptionEventArgs(ex));
			}
		}