C# Socket編程 同步以及異步通訊

套接字簡介：套接字最先是Unix的，window是借鑑過來的。TCP/IP協議族提供三種套接字：流式、數據報式、原始套接字。其中原始套接字容許對底層協議直接訪問，通常用於檢驗新協議或者新設備問題，不多使用。

套接字編程原理：延續文件做用思想，打開-讀寫-關閉的模式。

C/S編程模式以下：

Ø  服務器端：

打開通訊通道，告訴本地機器，願意在該通道上接受客戶請求——監聽，等待客戶請求——接受請求，建立專用連接進行讀寫——處理完畢，關閉專用連接——關閉通訊通道（固然其中監聽到關閉專用連接能夠重複循環）

Ø  客戶端：打開通訊通道，鏈接服務器——數據交互——關閉信道。

Socket通訊方式：

Ø  同步：客戶端在發送請求以後必須等到服務器迴應以後才能夠發送下一條請求。串行運行

Ø  異步：客戶端請求以後，沒必要等到服務器迴應以後就能夠發送下一條請求。並行運行

套接字模式：

Ø  阻塞：執行此套接字調用時，全部調用函數只有在獲得返回結果以後纔會返回。在調用結果返回以前，當前進程會被掛起。即此套接字一直被阻塞在網絡調用上。

Ø  非阻塞：執行此套接字調用時，調用函數即便得不到獲得返回結果也會返回。

套接字工做步驟：

Ø  服務器監聽：監聽時服務器端套接字並不定位具體客戶端套接字，而是處於等待連接的狀態，實時監控網絡狀態

Ø  客戶端連接：客戶端發出連接請求，要鏈接的目標是服務器端的套接字。爲此客戶端套接字必須描述服務器端套接字的服務器地址與端口號。

Ø  連接確認：是指服務器端套接字監聽到客戶端套接字的連接請求時，它響應客戶端連接請求，創建一個新的線程，把服務器端套接字的描述發送給客戶端，一旦客戶端確認此描述，則連接創建好。而服務器端的套接字繼續處於監聽狀態，繼續接受其餘客戶端套接字請求。

在TCP/IP網絡中，IP網絡交互分類兩大類：面向鏈接的交互與面向無鏈接的交互。

Socket構造函數：public socket(AddressFamily 尋址類型, SocketType 套接字類型, ProtocolType 協議類型)。但須要注意的是套接字類型與協議類型並非能夠隨便組合。

SocketType			ProtocolType					描述
Stream			Tcp					面向鏈接
Dgram			Udp					面向無鏈接
Raw			Icmp					網際消息控制
Raw			Raw					基礎傳輸協議
Socket類的公共屬性：
屬性名					描述
AddressFamily				獲取Socket的地址族
Available				獲取已經從網絡接收且可供讀取的數據量
Blocking				獲取或設置一個值，只是socket是否處於阻塞模式
Connected				獲取一個值，指示當前鏈接狀態
Handle				獲取socket的操做系統句柄
LocalEndPoint				獲取本地終端EndPoint
RemoteEndPoint				獲取遠程終端EndPoint
ProtocolType				獲取協議類型
SocketType				獲取SocketType類型
Socket經常使用方法：
Bind(EndPoint)		服務器端套接字須要綁定到特定的終端，客戶端也能夠先綁定再請求鏈接
Listen(int)		監聽端口，其中parameters表示最大監聽數
Accept()		接受客戶端連接，並返回一個新的連接，用於處理同客戶端的通訊問題
Send()	發送數據
	Send(byte[])					簡單發送數據
	Send(byte[],SocketFlag)					使用指定的SocketFlag發送數據
	Send(byte[], int, SocketFlag)					使用指定的SocketFlag發送指定長度數據
	Send(byte[], int, int, SocketFlag)					使用指定的SocketFlag，將指定字節數的數據發送到已鏈接的socket(從指定偏移量開始)
Receive()	接受數據
	Receive(byte[])						簡單接受數據
	Receive (byte[],SocketFlag)						使用指定的SocketFlag接受數據
	Receive (byte[], int, SocketFlag)						使用指定的SocketFlag接受指定長度數據
	Receive (byte[], int, int, SocketFlag)						使用指定的SocketFlag，從綁定的套接字接收指定字節數的數據，並存到指定偏移量位置的緩衝區
Connect(EndPoint)		鏈接遠程服務器
ShutDown(SocketShutDown)		禁用套接字，其中SocketShutDown爲枚舉，Send禁止發送，Receive爲禁止接受，Both爲二者都禁止
Close()		關閉套接字，釋放資源
異步通訊方法：
BeginAccept(AsynscCallBack,object)		開始一個一步操做接受一個鏈接嘗試。參數：一個委託。一個對象。對象包含此請求的狀態信息。其中回調方法中必須使用EndAccept方法。應用程序調用BegineAccept方法後，系統會使用單獨的線程執行指定的回調方法並在EndAccept上一直處於阻塞狀態，直至監測到掛起的連接。EndAccept會返回新的socket對象。供你來同遠程主機數據交互。不能使用返回的這個socket接受隊列中的任何附加鏈接。調用BeginAccept當但願原始線程阻塞的時候，請調用WaitHandle.WaitOne方法。當須要原始線程繼續執行時請在回調方法中使用ManualResetEvent的set方法
BeginConnect(EndPoint, AsyncCallBack, Object)		回調方法中必須使用EndConnect()方法。Object中存儲了鏈接的詳細信息。
BeginSend(byte[], SocketFlag, AsyncCallBack, Object)
BegineReceive(byte[], SocketFlag, AsyncCallBack, Object)
BegineDisconnect(bool, AsyncCallBack, Object)

給出同步通訊與異步通訊的示例：

同步通訊：

預約義結構體，同步通訊沒有多線程異步委託回調，因此無需預約義結構體

客戶端Client：

class Program {         static void Main()         {             try{                 int port = 2000;                 string host = "127.0.0.1";                 IPAddress ip = IPAddress.Parse(host);                 IPEndPoint ipe = new IPEndPoint(ip, port);//把ip和端口轉化爲IPEndPoint實例                 Socket c = new Socket(AddressFamily.InterNetwork, SocketType.Stream,ProtocolType.Tcp);//建立一個Socket                 Console.WriteLine("Conneting...");                 c.Connect(ipe);//鏈接到服務器                 string sendStr = "hello!This is a socket test";                 byte[] bs = Encoding.ASCII.GetBytes(sendStr);                 Console.WriteLine("Send Message");                 c.Send(bs, bs.Length, 0);//發送測試信息                 string recvStr = "";                 byte[] recvBytes = new byte[1024];                 int bytes;                 bytes = c.Receive(recvBytes, recvBytes.Length, 0);//從服務器端接受返回信息                 recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);                 Console.WriteLine("Client Get Message:{0}", recvStr);//顯示服務器返回信息                 c.Close();             }             catch (ArgumentNullException e){                 Console.WriteLine("ArgumentNullException: {0}", e);             }             catch (SocketException e){                 Console.WriteLine("SocketException: {0}", e);             }             Console.WriteLine("Press Enter to Exit");             Console.ReadLine();         } }

服務器端：

class Program {     static void Main()     {         try{             int port = 2000;             string host = "127.0.0.1";             IPAddress ip = IPAddress.Parse(host);             IPEndPoint ipe = new IPEndPoint(ip, port);             Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream,ProtocolType.Tcp);//建立一個Socket類             s.Bind(ipe);//綁定2000端口             s.Listen(0);//開始監聽             Console.WriteLine("Wait for connect");             Socket temp = s.Accept();//爲新建鏈接建立新的Socket。             Console.WriteLine("Get a connect");             string recvStr = "";             byte[] recvBytes = new byte[1024];             int bytes;             bytes = temp.Receive(recvBytes, recvBytes.Length, 0);//從客戶端接受信息             recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);             Console.WriteLine("Server Get Message:{0}", recvStr);//把客戶端傳來的信息顯示出來             string sendStr = "Ok!Client Send Message Sucessful!";             byte[] bs = Encoding.ASCII.GetBytes(sendStr);             temp.Send(bs, bs.Length, 0);//返回客戶端成功信息             temp.Close();             s.Close();         }         catch (ArgumentNullException e){             Console.WriteLine("ArgumentNullException: {0}", e);}         catch (SocketException e){             Console.WriteLine("SocketException: {0}", e);}         Console.WriteLine("Press Enter to Exit");         Console.ReadLine();     } }

 

 

異步通訊：

客戶端Client：

預約義結構體，用於異步委託之間的傳遞。用戶根據本身須要定製便可

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(); }

正文：

public class AsynchronousClient {     // The port number for the remote device.     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(){         // Connect to a remote device.         try{             // Establish the remote endpoint for the socket.             // The name of the remote device is "host.contoso.com".             IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com");             IPAddress ipAddress = ipHostInfo.AddressList[0];             IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);               // Create a TCP/IP socket.             Socket client = new Socket(AddressFamily.InterNetwork,                 SocketType.Stream, ProtocolType.Tcp);               // Connect to the remote endpoint.             client.BeginConnect(remoteEP,                 new AsyncCallback(ConnectCallback), client);             connectDone.WaitOne();               // Send test data to the remote device.             Send(client, "This is a test<EOF>");             sendDone.WaitOne();               // Receive the response from the remote device.             Receive(client);             receiveDone.WaitOne();               // Write the response to the console.             Console.WriteLine("Response received : {0}", response);               // Release the 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;               // Complete the connection.             client.EndConnect(ar);               Console.WriteLine("Socket connected to {0}",                 client.RemoteEndPoint.ToString());               // Signal that the connection has been made.             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;               // Begin receiving the data from the remote device.             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));                   // Get the rest of the data.                 client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,                     new AsyncCallback(ReceiveCallback), state);             }             else{                 // All the data has arrived; put it in response.                 if (state.sb.Length > 1)                 {                     response = state.sb.ToString();                 }                 // Signal that all bytes have been received.                 receiveDone.Set();             }         }         catch (Exception e){             Console.WriteLine(e.ToString());}     }       private static void Send(Socket client, String data)     {         // Convert the string data to byte data using ASCII encoding.         byte[] byteData = Encoding.ASCII.GetBytes(data);           // Begin sending the data to the remote device.         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;               // Complete sending the data to the remote device.             int bytesSent = client.EndSend(ar);             Console.WriteLine("Sent {0} bytes to server.", bytesSent);               // Signal that all bytes have been sent.             sendDone.Set(); }         catch (Exception e){             Console.WriteLine(e.ToString());}     }       public static int Main(String[] args)     {         StartClient();         return 0;     } }

服務器端Server：

預約義結構體，用於異步委託之間的傳遞。同客戶端的一致。再也不贅述

正文：

// State object for reading client data asynchronously public class AsynchronousSocketListener {     // Thread signal.     public static ManualResetEvent allDone = new ManualResetEvent(false);     public AsynchronousSocketListener(){}     public static void StartListening()     {         // Data buffer for incoming data.         byte[] bytes = new Byte[1024];         // Establish the local endpoint for the socket.         // The DNS name of the computer         // running the listener is "host.contoso.com".           //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());         IPHostEntry ipHostInfo = Dns.Resolve("127.0.0.1");         IPAddress ipAddress = ipHostInfo.AddressList[0];         IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);         // Create a TCP/IP socket.         Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);         // Bind the socket to the local endpoint and listen for incoming connections.         try{             listener.Bind(localEndPoint);             listener.Listen(100);             while (true){                 // Set the event to nonsignaled state.                 allDone.Reset();                 // Start an asynchronous socket to listen for connections.                 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("\nPress ENTER to continue...");         Console.Read();     }     public static void AcceptCallback(IAsyncResult ar)     {         // Signal the main thread to continue.         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,newAsyncCallback(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));             // Check for end-of-file tag. If it is not there, read             // more data.             content = state.sb.ToString();             if (content.IndexOf("<EOF>") > -1){                 // All the data has been read from the                 // client. Display it on the console.                 Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",                 content.Length, content);                 // Echo the data back to the client.                 Send(handler, "Server return :" + content);             }             else{                 // Not all data received. Get more.                 handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,                 new AsyncCallback(ReadCallback), state);             }         }     }     private static void Send(Socket handler, String data){         // Convert the string data to byte data using ASCII encoding.         byte[] byteData = Encoding.ASCII.GetBytes(data);         // Begin sending the data to the remote device.         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;             // Complete sending the data to the remote device.             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;     } }