Socket編程--簡單非同步(異步)服務端與客戶端示例

以下非同步(異步)示例全部使用tcp協議.

1.在編寫服務端及客戶端代碼之前,先編寫一個共用的用於保存接收信息的類:

   //接收到的數據 State object for receiving data from remote device. 
    public class StateObject
    {
        // Client socket. 
        public Socket workSocket = null;
        // Size of receive buffer. 
        public const int BufferSize = 256;
        // Receive buffer. 
        public byte[] buffer = new byte[BufferSize];
        // Received data string. 
        public StringBuilder sb = new StringBuilder();
    }

2.服務端示例:

 示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用异步套接字生成的，因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串，在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“<EOF>”， 以发出表示消息结尾的信号。

    public class AsynchronousSocketListener
    {
        // 定義線程標識 
        public static ManualResetEvent allDone = new ManualResetEvent(false);
        public AsynchronousSocketListener()
        {
        }
        public static void StartListening()
        {
            // 暫存接收數據
            byte[] bytes = new Byte[1024];
            // 建立本地端口 
            // The DNS name of the computer running the listener is "host.contoso.com". 
            IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
            // 建立socket
            Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // Bind本地端口並偵聽連接
            try
            {
                listener.Bind(localEndPoint);
                listener.Listen(100);
                while (true)
                {
                    // Set the event to nonsignaled state. 
                    allDone.Reset();
                    // 開始偵聽  
                    Console.WriteLine("Waiting for a connection...");
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                    // 暫停直到有新的連接 Wait until a connection is made before continuing. 
                    allDone.WaitOne();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
            Console.WriteLine(" Press ENTER to continue...");
            Console.Read();
        }
        public static void AcceptCallback(IAsyncResult ar)
        {
            // 標識主線程繼續 
            allDone.Set();
            // Get the socket that handles the client request. 
            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);
            // Create the state object. 
            StateObject state = new StateObject();
            state.workSocket = handler;
            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
        }
        public static void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;
            // Retrieve the state object and the handler socket 
            // from the asynchronous state object. 
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;
            // Read data from the client socket.  
            int bytesRead = handler.EndReceive(ar);
            if (bytesRead > 0)
            {
                // There  might be more data, so store the data received so far. 
                state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
                // 檢查是否含有文件尾標識,如果沒有,繼續讀取數據
                content = state.sb.ToString();
                if (content.IndexOf("<EOF>") > -1)
                {
                    // 顯示接收到的數據 
                    Console.WriteLine("Read {0} bytes from socket.   Data : {1}", content.Length, content);
                    // 發送數據 Echo the data back to the client. 
                    Send(handler, content);
                }
                else
                {
                    // 繼續接收數據 
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
                }
            }
        }
        private static void Send(Socket handler, String data)
        {
            // 將字符串轉化為字節數組
            byte[] byteData = Encoding.ASCII.GetBytes(data);
            // 開始發送數據 
            handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
        }
        private static void SendCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the socket from the state object. 
                Socket handler = (Socket)ar.AsyncState;
                // 完成發送數據
                int bytesSent = handler.EndSend(ar);
                Console.WriteLine("Sent {0} bytes to client.", bytesSent);
                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        public static int Main(String[] args)
        {
            StartListening();
            return 0;
        }

    }

3.客戶端示例:

示例程序创建一个连接到服务器的客户端。该客户端是用异步套接字生成的，因此在等待服务器返回响应时不挂起客户端应用程序的执行。该应用程序将字符串发送到服务器，然后在控制台显示该服务器返回的字符串。

    public class AsynchronousClient
    {
        // 定義遠程端口
        private const int port = 11000;
        // ManualResetEvent instances signal completion. 
        private static ManualResetEvent connectDone = new ManualResetEvent(false);
        private static ManualResetEvent sendDone = new ManualResetEvent(false);
        private static ManualResetEvent receiveDone = new ManualResetEvent(false);
        // 接收到的數據 The response from the remote device. 
        private static String response = String.Empty;
        private static void StartClient()
        {
            // 連接遠程設備
            try
            { 
                // 建立遠程端口 
                IPHostEntry ipHostInfo = Dns.GetHostEntry("host.contoso.com");
                IPAddress ipAddress = ipHostInfo.AddressList[0];
                IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
                // 建立socket
                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                // 連接遠程端口
                client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
                connectDone.WaitOne();
                // 發送數據
                Send(client, "This is a test<EOF>");
                sendDone.WaitOne();
                // 接收數據
                Receive(client);
                receiveDone.WaitOne();
                // 顯示接收到的數據
                Console.WriteLine("Response received : {0}", response);
                // 關閉socket 
                client.Shutdown(SocketShutdown.Both);
                client.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        private static void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the socket from the state object. 
                Socket client = (Socket)ar.AsyncState;
                // 完成連接
                client.EndConnect(ar);
                Console.WriteLine("Socket connected to {0}",
                client.RemoteEndPoint.ToString());
                // 標識連接完成
                connectDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        private static void Receive(Socket client)
        {
            try
            {
                // Create the state object. 
                StateObject state = new StateObject();
                state.workSocket = client;
                // 開始接收數據 
                client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        private static void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the state object and the client socket  
                // from the asynchronous state object. 
                StateObject state = (StateObject)ar.AsyncState;
                Socket client = state.workSocket;
                // Read data from the remote device. 
                int bytesRead = client.EndReceive(ar);
                if (bytesRead > 0)
                {
                    // There might be more data, so store the data received so far. 
                    state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
                    // 繼續接收數據 
                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                }
                else
                {
                    //數據接收完後,顯示數據.
                    if (state.sb.Length > 1)
                    {
                        response = state.sb.ToString();
                    }
                    //標識數據接收完畢
                    receiveDone.Set();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        private static void Send(Socket client, String data)
        {
            //將字符串轉化為ascii字節數組
            byte[] byteData = Encoding.ASCII.GetBytes(data);
            // 開始發送數據 
            client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
        }
        private static void SendCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the socket from the state object. 
                Socket client = (Socket)ar.AsyncState;
                // 完成發送數據
                int bytesSent = client.EndSend(ar);
                Console.WriteLine("Sent {0} bytes to server.", bytesSent);
                // 標識數據發送完畢 
                sendDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
       public static int Main(String[] args)
        {
            StartClient();
            return 0;
        }

    }

 

參考文獻: 1. http://www.jb51.net/html/200703/85/8049.htm