private void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
 {
     if ((m_handler != null) && m_running)
     {
         IAsyncAction asyncAction = ThreadPool.RunAsync((workItem) =>
             {
                 StreamSocket s = args.Socket;
                 try
                 {
                     m_handler(
                         this,
                         s.Information.RemoteHostName.CanonicalName.ToString(),
                         s.InputStream.AsStreamForRead(),
                         s.OutputStream.AsStreamForWrite()
                         );
                 }
                 catch (Exception)
                 {
                     // Quietly consume the exception
                 }
                 // Close the client socket
                 s.Dispose();
             });
     }
 }

        private void listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            this.Log("new Connection received");
            _output = args.Socket.OutputStream;
            try
            {
                using (var reader = new StreamReader(args.Socket.InputStream.AsStreamForRead()))
                {
                    while (!reader.EndOfStream)
                    {
                        var nextLine = reader.ReadLine();
                        this.Log(nextLine);
                        _input.OnNext(nextLine);
                    }
                }
                _input.OnCompleted();

            }
            catch (Exception ex)
            {
                this.Log("exception, invalidating socket stuff");
                InvalidateSocketStuff();
                _input.OnError(ex);
            }
        }

 private void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
 {
     if (this.OnConnectionReceived != null)
     {
         this.OnConnectionReceived(args.Socket);
     }
 }

        private async void OnConnectionReceived(
            StreamSocketListener sender,
            StreamSocketListenerConnectionReceivedEventArgs args)
        {
            try
            {
                DisplayOutput(TcpServerOutput, args.Socket.Information.RemoteAddress.DisplayName + " connected.");

                while (true)
                {
                    // Read request.
                    string request = await ReadUntilCrLf(args.Socket.InputStream, TcpServerOutput);
                    if (String.IsNullOrEmpty(request))
                    {
                        // If there was no request. The remote host closed the connection.
                        return;
                    }
                    DisplayOutput(TcpServerOutput, request);

                    // Send response.
                    string response = "Yes, I am ñoño. The time is " + DateTime.Now + ".\r\n";

                    // In this sample since the server doesn´t close the close the socket, we
                    // could do it async (i.e. without await)., but not now.
                    await Send(args.Socket.OutputStream, response);
                }
            }
            catch (Exception ex)
            {
                DisplayOutput(TcpServerOutput, ex.ToString());
            }
        }

 private async void TcpServer_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
 {
     if (isRunning)
     {
         await ThreadPool.RunAsync(new WorkItemHandler((IAsyncResult) => AddClient(args)));
     }
 }

        private async void OnConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            playPage.DisplayMessages(name + " :Recived TCP: start");
            try
            {
                playPage.DisplayMessages(name + " " + args.Socket.Information.RemoteAddress.DisplayName + " connected.");
                while (true)
                {
                    string request = await Read(args.Socket.InputStream);

                    if (String.IsNullOrEmpty(request))
                    {
                        return;
                    }
                    playPage.DisplayMessages(name + " :Recived TCP: " + request);
                    OnReceived(request, args.Socket.Information.RemoteAddress.DisplayName, args.Socket.Information.RemotePort);
                    //string response = "Respone.\r\n";
                    //await Send(args.Socket.OutputStream, response);
                }
            }
            catch (Exception ex)
            {
                playPage.DisplayMessages(name + " :Recived TCP\n" + ex.ToString());
            }
        }

 // private AppServiceConnection appServiceConnection;
 public TinyHttpdServer(int serverPort)
 {
     listener = new StreamSocketListener();
     port = serverPort;
     listener.ConnectionReceived += (s, e) =>
                     ProcessRequestAsync(e.Socket);
 }

        public HttpServer(int serverPort, Func<string, string> apiProcessor , string basePath = "", string[] allowOrigins = null)
        {
            listener = new StreamSocketListener();
            port = serverPort;
            ApiProccessor = apiProcessor;

            if (allowOrigins != null)
            {
                var allowOriginsHeadersBuilder = new StringBuilder();
                foreach (var url in allowOrigins)
                {
                    allowOriginsHeadersBuilder.AppendFormat("Access-Control-Allow-Origin: {0}\r\n",url );  
                }

                allowOriginsHeadersBuilder.Append("Access-Control-Allow-Methods: GET\r\n");
                AllowOriginsHeader = allowOriginsHeadersBuilder.ToString();
            }
            else
            {
                AllowOriginsHeader = "Access-Control-Allow-Origin: *\r\n";
            }
            if (!string.IsNullOrWhiteSpace(basePath))
            {
                BasePath = basePath.Replace("\\", "/");
            }
            listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.Socket);
        }

 /// <summary>
 /// 受付開始
 /// </summary>
 public async void Start()
 {
     listener = new StreamSocketListener();
     listener.ConnectionReceived += Listener_ConnectionReceived;
     // await listener.BindEndpointAsync(LOCALHOST, PORT.ToString());
     await listener.BindServiceNameAsync(PORT.ToString());
 }

        /// <summary>
        /// Called when [connection].
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="args">The <see cref="StreamSocketListenerConnectionReceivedEventArgs" /> instance containing the event data.</param>
        private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            StringBuilder request = new StringBuilder();
            try
            {
                // Get the whole request.
                using (IInputStream inputStream = args.Socket.InputStream)
                {
                    Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(BufferLength);
                    do
                    {
                        await inputStream.ReadAsync(buffer, BufferLength, InputStreamOptions.Partial);
                        request.Append(Encoding.UTF8.GetString(buffer.ToArray(), 0, (int)buffer.Length));
                    }
                    while (buffer.Length == BufferLength);
                }

                // Write the response.
                using (IOutputStream output = args.Socket.OutputStream)
                {
                    await output.WriteAsync(this.CreateResponse());
                }
            }
            catch (Exception exception)
            {
                // If this is an unknown status it means that the error is fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }
            }
        }

        private static async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            ConnectionStatus = ConnectionStatus.Connected;
            DataReader reader = new DataReader(args.Socket.InputStream);
            try
            {
                while (true)
                {
                    uint sizeFieldCount = await reader.LoadAsync(sizeof (uint));
                    if (sizeFieldCount != sizeof (uint))
                    {
                        return;
                    }
                    
                    uint stringLength = reader.ReadUInt32();
                    uint actualStringLength = await reader.LoadAsync(stringLength);
                    if (stringLength != actualStringLength)
                    {
                        return;
                    }

                    Message = reader.ReadString(actualStringLength);
                }
            }
            catch (Exception e)
            {
                ConnectionStatus = ConnectionStatus.Failed;
                //TODO:send a connection status message with error
            }
        }

 public RestServer(int serverPort, AppServiceConnection connection)
 {
     listener = new StreamSocketListener();
     port = serverPort;
     appServiceConnection = connection;
     listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.Socket);
 }

		public void Ctor_ServiceName()
		{
			const string serviceName = "monkeyService";
			var listener = new StreamSocketListener (serviceName);

			Assert.AreEqual (serviceName, listener.ServiceName);
		}

 private void TcpServer_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
 {
     if (isRunning)
     {
         ClientAdded(this, new CustomEventArgs(args.Socket));
     }
 }

    private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
    {
        socket = args.Socket;
        var dr = new DataReader(socket.InputStream);

        /// GET ヘッダを取り出し
        StringBuilder request = new StringBuilder();
        uint BufferSize = 1024;
        using (IInputStream input = socket.InputStream)
        {
            byte[] data = new byte[BufferSize];
            IBuffer buffer = data.AsBuffer();
            uint dataRead = BufferSize;
            while (dataRead == BufferSize)
            {
                await input.ReadAsync(buffer, BufferSize, InputStreamOptions.Partial);
                request.Append(Encoding.UTF8.GetString(data, 0, data.Length));
                dataRead = buffer.Length;
            }
        }
        // GET method を取り出し
        string requestMethod = request.ToString().Split('\n')[0];
        string[] requestParts = requestMethod.Split(' ');
        var text = requestParts[1];

        /// GETコマンドの受信イベント
        if (this.OnReceived != null)
        {
            OnReceived(text);
        }
    }

 public HttpServer(int serverPort)
 {
     listener = new StreamSocketListener();
     port = serverPort;
     listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.Socket);
     Debug.WriteLine("HttpServer Init");
 }

 internal HttpServer(int serverPort)
 {
     _listener = new StreamSocketListener();
     _requestParser = new HttpRequestParser();
     _port = serverPort;
     _listener.ConnectionReceived += ProcessRequestAsync;
 }

        /// <summary>
        /// 服务器监听
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private  async void listenButton_Click(object sender, RoutedEventArgs e)
        {
            if (listener != null)
            {
                await new MessageDialog("监听已经启动了").ShowAsync();
                return;
            }
            listener= new StreamSocketListener();
            //监听后连接的事件OnConnection
            listener.ConnectionReceived += OnConnection;
            //开始监听操作
            try
            {
                await listener.BindServiceNameAsync("22112");
                await new MessageDialog("正在监听").ShowAsync();
            }

            catch (Exception ex)
            {
                listener = null;
                //未知异常
                if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }
            }
        }

        private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {

            DataReader reader = new DataReader(args.Socket.InputStream);
            try
            {
                while (true)
                {
                    // Read first 4 bytes (length of the subsequent string).
                    uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
                    if (sizeFieldCount != sizeof(uint))
                    {
                        // The underlying socket was closed before we were able to read the whole data.
                        return;
                    }

                    // Read the string.
                    uint stringLength = reader.ReadUInt32();
                    uint actualStringLength = await reader.LoadAsync(stringLength);
                    if (stringLength != actualStringLength)
                    {
                        // The underlying socket was closed before we were able to read the whole data.
                        return;
                    }

                    // Display the string.
                    string text = reader.ReadString(actualStringLength);

                    string InLang = "en";
                    string outLang = "es-MX";
                    Translator Trans = new Translator(text, InLang, outLang);
                    string translatedS = Trans.GetTranslatedString();

                    SpeechSynthesisStream stream = await synthesizer.SynthesizeTextToStreamAsync(translatedS);
                    var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                    {
                        media.SetSource(stream, stream.ContentType);
                        media.Play();
                        originalmsg.Text = text;
                        ReceivedText.Text = translatedS;
                        ReceivedText.FontSize = 20;
                    });
                }
            }
            catch (Exception exception)
            {
                // If this is an unknown status it means that the error is fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }
                var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    StatusText.Text = "Error in Socket reading data from Remote host: " + exception.Message;
                    connected = false;
                    CoreApplication.Properties.Remove("clientSocket");
                    CoreApplication.Properties.Remove("clientDataWriter");
                });
            }
        }

        private async void StartServer_Click_1(object sender, RoutedEventArgs e)
        {
            try
            {
                if (listener == null)
                {
                    // We call it 'local', becuase if this connection doesn't succeed, we do not want
                    // to loose the possible previous conneted listener.
                    listener = new StreamSocketListener();

                    // ConnectionReceived handler must be set before BindServiceNameAsync is called, if not
                    // "A method was called at an unexpected time. (Exception from HRESULT: 0x8000000E)"
                    // error occurs.
                    listener.ConnectionReceived += OnConnectionReceived;

                    // Trying to bind more than once to the same port throws "Only one usage of each socket
                    // address (protocol/network address/port) is normally permitted. (Exception from
                    // HRESULT: 0x80072740)" exception.
                    await listener.BindServiceNameAsync("80");
                    DisplayOutput(TcpServerOutput, "Listening.");
                }
            }
            catch (Exception ex)
            {
                DisplayOutput(TcpServerOutput, ex.ToString());
            }
        }