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

using System;  
using System.Net;  
using System.Net.Sockets;  
using System.Threading;  
using System.Text;  
  
// State object for receiving data from remote device.  
public class StateObject {  
    public Socket workSocket = null;              // Socket连接的对象 
    public const int BufferSize = 256;            // 客户端接受socket数据的缓冲区字节数大小 
    public byte[] buffer = new byte[BufferSize];  // 客户端接受socket数据的缓冲区
    public StringBuilder sb = new StringBuilder();// 客户端接受数据字符串的容器
}  
  
public class AsynchronousClient {  
    private const int port = 11000;   // 端口号
  
    // ManualResetEvent类详见 http://www.cnblogs.com/li-peng/p/3291306.html
    // 当初始化为true时，为终止状态
    // 当初始化为false时，为非终止状态
    // 终止状态时调用成员方法WaitOne()允许线程访问下边的语句
    // 非终止状态时调用成员方法WaitOne()阻塞线程，不允许线程访问下边的语句
    private static ManualResetEvent connectDone = new ManualResetEvent(false);  
    private static ManualResetEvent sendDone = new ManualResetEvent(false);
    private static ManualResetEvent receiveDone = new ManualResetEvent(false);
    private static String response = String.Empty; // 从服务端处收到的字符串 
  
    private static void StartClient() {  
        try {  
            // 利用DNS解析域名，获得目标服务器的IP
            IPHostEntry ipHostInfo = Dns.GetHostEntry("host.contoso.com");  
            IPAddress ipAddress = ipHostInfo.AddressList[0];  
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);  
  
            // 创建连接用的socket，使用TCP，流式数据  
            Socket client = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
  
            // 开始连接服务器，注意这里的第三个参数，当传递client进去的时候，传给回调函数ConnectCallback
            // 中IAsyncResult类参数ar的AsyncState，就是这个client
            client.BeginConnect( remoteEP, new AsyncCallback(ConnectCallback), client);

            // 因为一开始connectDone处于非终止状态，所以这里执行了WaitOne方法之后，会阻塞住当前的线程
            // 直到在ConnectCallback函数中connectDone执行了Set()方法为止
            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 {  
            // 在BeginConnect中传递过来的第三个参数就是Socket对象
            Socket client = (Socket) ar.AsyncState;  
  
            // 完成后，一个BeginConnect就要对应一个EndConnect
            client.EndConnect(ar);  
  
            // 打印输出
            Console.WriteLine("Socket connected to {0}",client.RemoteEndPoint.ToString());  
  
            // 通知完成，让StartClient函数所处线程解除阻塞，往下执行。
            connectDone.Set();  
        } catch (Exception e) {  
            Console.WriteLine(e.ToString());  
        }  
    }  
  
    private static void Receive(Socket client) {  
        try {  
            // 创建一个state object，这个object将要传递给ReceiveCallback方法
            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 {  
            // 拿到state object
            StateObject state = (StateObject) ar.AsyncState;  
            Socket client = state.workSocket;  
  
            // 看看从服务端收到多少字节的数据
            int bytesRead = client.EndReceive(ar);  
  
            if (bytesRead > 0) {  
                // 收到多少，就把它格式化一下，编码成字符串
                state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));  
  
                // 因为不是一次收完所有服务端要发送过来的数据，所以再继续首收发
                client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,  
                    new AsyncCallback(ReceiveCallback), state);  
            } else {  
                // 收到的字节数为0了，表示收取完毕了
                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) {  
        // 编码并发送数据到服务端
        byte[] byteData = Encoding.ASCII.GetBytes(data); 
        client.BeginSend(byteData, 0, byteData.Length, 0,  
            new AsyncCallback(SendCallback), client);  
    }  
  
    private static void SendCallback(IAsyncResult ar) {  
        try {  
            // 发送完成
            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;  
    }  
}