NET Framework中的Socket类的BeginReceive和EndReceive成员方法详解

  1using System;  
  2using System.Net;  
  3using System.Net.Sockets;  
  4using System.Threading;  
  5using System.Text;  
  6  
  7// State object for receiving data from remote device.  
  8public class StateObject {  
  9    public Socket workSocket = null;              // Socket连接的对象 
 10    public const int BufferSize = 256;            // 客户端接受socket数据的缓冲区字节数大小 
 11    public byte[] buffer = new byte[BufferSize];  // 客户端接受socket数据的缓冲区
 12    public StringBuilder sb = new StringBuilder();// 客户端接受数据字符串的容器
 13}  
 14  
 15public class AsynchronousClient {  
 16    private const int port = 11000;   // 端口号
 17  
 18    // ManualResetEvent类详见 http://www.cnblogs.com/li-peng/p/3291306.html
 19    // 当初始化为true时，为终止状态
 20    // 当初始化为false时，为非终止状态
 21    // 终止状态时调用成员方法WaitOne()允许线程访问下边的语句
 22    // 非终止状态时调用成员方法WaitOne()阻塞线程，不允许线程访问下边的语句
 23    private static ManualResetEvent connectDone = new ManualResetEvent(false);  
 24    private static ManualResetEvent sendDone = new ManualResetEvent(false);
 25    private static ManualResetEvent receiveDone = new ManualResetEvent(false);
 26    private static String response = String.Empty; // 从服务端处收到的字符串 
 27  
 28    private static void StartClient() {  
 29        try {  
 30            // 利用DNS解析域名，获得目标服务器的IP
 31            IPHostEntry ipHostInfo = Dns.GetHostEntry("host.contoso.com");  
 32            IPAddress ipAddress = ipHostInfo.AddressList[0];  
 33            IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);  
 34  
 35            // 创建连接用的socket，使用TCP，流式数据  
 36            Socket client = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
 37  
 38            // 开始连接服务器，注意这里的第三个参数，当传递client进去的时候，传给回调函数ConnectCallback
 39            // 中IAsyncResult类参数ar的AsyncState，就是这个client
 40            client.BeginConnect( remoteEP, new AsyncCallback(ConnectCallback), client);
 41
 42            // 因为一开始connectDone处于非终止状态，所以这里执行了WaitOne方法之后，会阻塞住当前的线程
 43            // 直到在ConnectCallback函数中connectDone执行了Set()方法为止
 44            connectDone.WaitOne();  
 45  
 46            // 向服务端发送消息，然后阻塞本线程，直到发送成功
 47            Send(client,"This is a test<EOF>");  
 48            sendDone.WaitOne();  
 49  
 50            // 收取服务端对本客户端发送的消息的应答，然后阻塞本线程，直到收取完成
 51            Receive(client);
 52            receiveDone.WaitOne();
 53  
 54            // 打印出从服务端接受到的信息
 55            Console.WriteLine("Response received : {0}", response);  
 56  
 57            // 关闭socket连接
 58            client.Shutdown(SocketShutdown.Both);  
 59            client.Close();  
 60  
 61        } catch (Exception e) {  
 62            Console.WriteLine(e.ToString());  
 63        }  
 64    }  
 65  
 66    private static void ConnectCallback(IAsyncResult ar) {  
 67        try {  
 68            // 在BeginConnect中传递过来的第三个参数就是Socket对象
 69            Socket client = (Socket) ar.AsyncState;  
 70  
 71            // 完成后，一个BeginConnect就要对应一个EndConnect
 72            client.EndConnect(ar);  
 73  
 74            // 打印输出
 75            Console.WriteLine("Socket connected to {0}",client.RemoteEndPoint.ToString());  
 76  
 77            // 通知完成，让StartClient函数所处线程解除阻塞，往下执行。
 78            connectDone.Set();  
 79        } catch (Exception e) {  
 80            Console.WriteLine(e.ToString());  
 81        }  
 82    }  
 83  
 84    private static void Receive(Socket client) {  
 85        try {  
 86            // 创建一个state object，这个object将要传递给ReceiveCallback方法
 87            StateObject state = new StateObject();  
 88            state.workSocket = client;  
 89  
 90            // 开始从服务端处接受数据
 91            client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,  
 92                new AsyncCallback(ReceiveCallback), state);  
 93        } catch (Exception e) {  
 94            Console.WriteLine(e.ToString());  
 95        }  
 96    }  
 97  
 98    private static void ReceiveCallback( IAsyncResult ar ) {  
 99        try {  
100            // 拿到state object
101            StateObject state = (StateObject) ar.AsyncState;  
102            Socket client = state.workSocket;  
103  
104            // 看看从服务端收到多少字节的数据
105            int bytesRead = client.EndReceive(ar);  
106  
107            if (bytesRead > 0) {  
108                // 收到多少，就把它格式化一下，编码成字符串
109                state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));  
110  
111                // 因为不是一次收完所有服务端要发送过来的数据，所以再继续首收发
112                client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,  
113                    new AsyncCallback(ReceiveCallback), state);  
114            } else {  
115                // 收到的字节数为0了，表示收取完毕了
116                if (state.sb.Length > 1) {  
117                    response = state.sb.ToString();  
118                }  
119                // 通知线程解除阻塞
120                receiveDone.Set();  
121            }  
122        } catch (Exception e) {  
123            Console.WriteLine(e.ToString());  
124        }  
125    }  
126  
127    private static void Send(Socket client, String data) {  
128        // 编码并发送数据到服务端
129        byte[] byteData = Encoding.ASCII.GetBytes(data); 
130        client.BeginSend(byteData, 0, byteData.Length, 0,  
131            new AsyncCallback(SendCallback), client);  
132    }  
133  
134    private static void SendCallback(IAsyncResult ar) {  
135        try {  
136            // 发送完成
137            Socket client = (Socket) ar.AsyncState;  
138 
139            // 拿到实际发送的字节数，并打印出来
140            int bytesSent = client.EndSend(ar);  
141            Console.WriteLine("Sent {0} bytes to server.", bytesSent);  
142  
143            // 通知线程解除阻塞
144            sendDone.Set();  
145        } catch (Exception e) {  
146            Console.WriteLine(e.ToString());  
147        }  
148    }  
149  
150    public static int Main(String[] args) {  
151        StartClient();  
152        return 0;  
153    }  
154}