c# Socket通信异步TCP

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace ConsoleApplication2
{
    public class StateObject
    {
        public Socket newsocket = null;
        public const int bufferSize = 256;
        public byte[] buffer=new byte[bufferSize];
        public StringBuilder sb = new StringBuilder();

    }
    public class AsynchronousClient
    {
        private const int port = 20150;
        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;


        public static void StartClient()
        {
            try
            {
                IPAddress ipAddress = IPAddress.Parse("192.168.20.215");
                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();
                byte[] b = new byte[] { 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x13, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x30, 0x00, 0x04 };
                //发送数据
                Send(client, b);
                sendDone.WaitOne();
                Receive(client);
                ReceiveDone.WaitOne();
                Console.WriteLine("Response{0}", response);
                client.Shutdown(SocketShutdown.Both);
                //Release the socket
                client.Close();
                Console.ReadLine();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        public static void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                //从state对象获取Socket
                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
            {
                //构造容器state
                StateObject state = new StateObject();
                state.newsocket = 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对象中获取state和socket对象
                StateObject state = (StateObject)ar.AsyncState;
                Socket client = state.newsocket;
                int bytesRead = client.EndReceive(ar);
                if (bytesRead > 0)
                {
                    //有数据存储
                    state.sb.Append(BitConverter.ToString(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, byte[] b)
        {
            //格式转换
            byte[] byteData = b;
            //开始发送数据到远程设备
            client.BeginSend(byteData,0,byteData.Length,0,new AsyncCallback(SendCallback),client);
        }
        private static void SendCallback(IAsyncResult ar)
        {
            try
            {
                //从state对象中获取socket
                Socket client = (Socket)ar.AsyncState;
                //完成数据发送
                int bytesSend = client.EndSend(ar);
                Console.WriteLine("Send {0} bytes to sever",bytesSend);
                //指示数据已经发送完成，主线程继续
                sendDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        public static int Main(string[] args)
        {
            StartClient();
            return 0;
        }
    }
}