MSDN里的异步socket例子每步都要WaitOne()。这样性能不是和同步一样了，那为什么不直接使用同步很省事呢？

public static int Main(String[] args)
        {            IPAddress ipAddress = IPAddress.Parse("82.98.86.169");
            int port = 80;
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
            // 生成一个TCP/IP socket.  
            Socket client = new Socket(AddressFamily.InterNetwork,
               SocketType.Stream, ProtocolType.Tcp);
            // 与目标终端连接.  
            client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
            //等待，直到连接程序完成。在ConnectCallback中适当位置有connecDone.Set()语句  
            connectDone.WaitOne();
            // 发送数据到远程终端.  
            StringBuilder buf = new StringBuilder();
            buf.Append("GET / HTTP/1.1\r\n");
            buf.Append("Host: stock.cdyee.com\r\n");
            buf.Append("User-agent: Mozilla/4.0\r\n");
            buf.Append("Accept-language: zh-cn\r\n");
            buf.Append("\r\n");            Send(client, buf.ToString());
            sendDone.WaitOne();
            // 接收返回数据.  
            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();
            Console.Beep();
            Console.Read();
            return 0;
        }        private static void ConnectCallback(IAsyncResult ar)
        {
            // 从state对象获取socket.  
            Socket client = (Socket)ar.AsyncState;
            // 完成连接.  
            client.EndConnect(ar);
            Console.WriteLine("Socket connected to {0}",
                client.RemoteEndPoint.ToString());
            // 连接已完成，主线程继续.  
            connectDone.Set();
        }
        private static void Receive(Socket client)
        {
            // 构造容器state.  
            StateObject state = new StateObject();
            state.workSocket = client;
            // 从远程目标接收数据.  
            client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReceiveCallback), state);
        }
        private static void ReceiveCallback(IAsyncResult ar)
        {
            // 从输入参数异步state对象中获取state和socket对象  
            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
            {
                // 所有数据读取完毕.  
                if (state.sb.Length > 1)
                {
                    response = state.sb.ToString();
                }
                // 所有数据读取完毕的指示信号.  
                receiveDone.Set();
            }
        }        private static void Send(Socket client, String data)
        {
            // 格式转换.  
            byte[] byteData = Encoding.Default.GetBytes(data);
            // 开始发送数据到远程设备.  
            client.BeginSend(byteData, 0, byteData.Length, 0,
                new AsyncCallback(SendCallback), client);
        }
        private static void SendCallback(IAsyncResult ar)
        {
            // 从state对象中获取socket  
            Socket client = (Socket)ar.AsyncState;
            // 完成数据发送.  
            int bytesSent = client.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to server.", bytesSent);
            // 指示数据已经发送完成，主线程继续.  
            sendDone.Set();
        }