全部代码using System;   
using System.Threading;   
using System.Net;   
using System.Net.Sockets;   
using System.Collections;   
  
  
namespace Zgke.Net   
{   
    /// <summary>   
    /// Tcp的异步操作   
    /// zgke@sina.com   
    /// </summary>   
    public class Tcp   
    {   
        public class TcpClient   
        {  
            #region 变量   
            /// <summary>   
            /// 端口号   
            /// </summary>   
            private int port = 8000;   
            /// <summary>   
            /// IP地址   
            /// </summary>   
            private IPAddress ip;  


            #endregion  

            #region 委托   
            /// <summary>   
            /// 接受数据   
            /// </summary>   
            public delegate void ReadByte(byte[] ReadByte);   
            public event ReadByte ReadBytes;  
            #endregion   
  
            public TcpClient(string IP, int Port)   
            {   
                if (Port != 0) port = Port;   
                if (IP != "") ip = IPAddress.Parse(IP);   
            }   
  
            /// <summary>   
            /// 反送消息   
            /// </summary>   
            /// <param name="SendByte">需要发送的数据</param>   
            public void SendByte(byte[] SendByte, bool Close)   
            {   
                Socket socket = new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  //建立SOCKET   
                IPEndPoint ipendpoint = new IPEndPoint(ip, port);  //建立IP目标和端口   
                socket.Connect(ipendpoint);//连接   
  
                socket.BeginSend(SendByte, 0, SendByte.Length, SocketFlags.None, null, socket); //发送数据   
  
                if (Close == true)   
                {   
                    socket.Close();   
                    return;   
                }   
                byte[] temp = new byte[1]; //建立个临时的发送数据   
                socket.BeginReceive(temp, 0, 0, SocketFlags.None, new AsyncCallback(Read), socket);  //建立异步读取                          
            }  

            #region 私有方法   
            private void Read(IAsyncResult iar)   
            {   
                Socket socket = (Socket)iar.AsyncState; //获取Socket对象   
  
                int ReadCount = socket.Available;  //获得包大小   
                if (ReadCount == 0) return;  //如果包是0 就直接返回   
                byte[] Byte = new byte[ReadCount];   //建立要接收的对象信息   
                socket.BeginReceive(Byte, 0, ReadCount, SocketFlags.None, null, socket); //开始读取   
                if (ReadBytes != null) ReadBytes(Byte);  //执行委托   
  
            }  


            #endregion   
        }   
  
        public class TcpServer   
        {   
            /// <summary>   
            /// 保存监听   
            /// </summary>   
            private Socket listener;   
            /// <summary>   
            /// 端口号   
            /// </summary>   
            private int TcpPort = 8000;   
            /// <summary>   
            /// IP地址   
            /// </summary>   
            private string TcpIP = "127.0.0.1";   
  
  
            /// <summary>   
            /// 默认地址池   
            /// </summary>   
            private int Bocklog = 10;   
  
  
            /// <summary>   
            /// 关闭标志   
            /// </summary>   
            private bool ServerRunTCP = false;   
  
            /// <summary>   
            /// 服务器运行状态   
            /// </summary>   
            public bool ServerRun   
            {   
                get { return ServerRunTCP; }   
            }   
  
  
            /// <summary>   
            /// 执行消息   
            /// </summary>   
            public delegate void MessageText(string MessageText);   
            public event MessageText Message;   
  
            /// <summary>   
            /// 读写数据   
            /// </summary>   
            public delegate void ReadByte(byte[] ReadByte, ref byte[] SendByte, ref bool Close);   
            public event ReadByte ReadBytes;   
  
  
  
  
            public TcpServer(string IP, int Port)   
            {   
                if (Port > 1) TcpPort = Port;   
                if (IP != "") TcpIP = IP;   
            }   
  
            public void Star()   
            {   
                if (ServerRun == true)   
                {   
                    Message("Server Runling....");   
                    return;   
                }   
  
                listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);   
  
                listener.Bind(new IPEndPoint(IPAddress.Parse(TcpIP), TcpPort));   
  
                listener.Listen(Bocklog);   
  
                listener.BeginAccept(new AsyncCallback(OnConnectRequest), listener);   
                ServerRunTCP = true;   
            }   
  
            public void Close()   
            {   
                if (ServerRun == false)   
                {   
                    Message("Server Not Run");   
                    return;   
                }   
                ServerRunTCP = false;   
                listener.Close();   
            }  


            #region 私有方法   
            private void OnConnectRequest(IAsyncResult ar)   
            {   
                if (ServerRunTCP == false) return;   
                Socket listener = (Socket)ar.AsyncState;   
                Socket sock = listener.EndAccept(ar);   
  
  
                listener.BeginAccept(new AsyncCallback(OnConnectRequest), listener);   
  
  
  
  
                if (Message != null) Message(sock.RemoteEndPoint.ToString() + " Join");   
  
  
                byte[] temp = new byte[0];   
                sock.BeginReceive(temp, 0, 0, SocketFlags.None, new AsyncCallback(OnRecievedData), sock);   
  
            }   
            private void OnRecievedData(IAsyncResult ar)   
            {   
  
                Socket sock = (Socket)ar.AsyncState;   
  
                if (ServerRunTCP == false)   
                {   
                    sock.Close();   
                    return;   
                }   
  
  
                int RecievedSize = sock.Available;   
  
  
  
                if (RecievedSize == 0)   
                {   
                    if (Message != null) Message(sock.RemoteEndPoint.ToString() + " Close");   
                    sock.Close();   
  
                    return;   
                }   
  
                byte[] RecievedData = new byte[RecievedSize];   
  
                sock.Receive(RecievedData);   
  
  
                if (Message != null) Message(sock.RemoteEndPoint.ToString() + " Read " + RecievedSize.ToString());   
  
                byte[] SendData = new byte[0];   
                bool CloseSock = false;   
                if (ReadBytes != null) ReadBytes(RecievedData, ref SendData, ref CloseSock);   
  
                if (SendData.Length != 0) sock.BeginSend(SendData, 0, SendData.Length, SocketFlags.None, null, sock);   
  
  
                if (CloseSock == true)   
                {   
                    sock.Close();   
                    return;   
                }   
                RecievedData = new byte[0];   
  
                sock.BeginReceive(RecievedData, 0, 0, SocketFlags.None, new AsyncCallback(OnRecievedData), sock);   
  
            }  

            #endregion   
  
        }   
  
  
    }   
}