异步Socket服务器及客户端

using System;
using System.IO;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;

namespace SocketServer
{
    /// <summary>
    /// 网络通讯事件模型委托
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e">与客户端的连接类</param>
    public delegate void NetEvent(object sender, TcpTranslate e);

    /// <summary>
    /// 监听端口,接受多客户的TCP连接
    /// </summary>
    public class TcpServer
    {
        #region 事件定义
        /// <summary>
        /// 接收客户端连接事件
        /// </summary>
        public event NetEvent Connected;
        /// <summary>
        /// 与客户端连接断开事件
        /// </summary>
        public event NetEvent DisConnect;
        #endregion

        #region 字段
        private int maxsockets = 10000;                 //最大客户连接数
        private IPEndPoint iep;                         //监听终结点
        private TcpListener listener;                   //监听类
        private Dictionary<EndPoint, TcpTranslate> session;
        #endregion

        #region 属性
        /// <summary>
        /// 当前客户连接数
        /// </summary>
        public int ConnectCount
        {
            get { return session.Count; }
        }
        /// <summary>
        /// 与客户连接的所有Socket
        /// </summary>
        public Dictionary<EndPoint, TcpTranslate> Session
        {
            get { return session; }
        }
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="port">监听的端口号</param>
        /// <param name="maxsocket">最大客户连接量</param>
        public TcpServer(int maxsockets, string IP, int port)
        {
            this.maxsockets = maxsockets;
            iep = new IPEndPoint(IPAddress.Parse(IP), port);
        }
        public TcpServer(int port)
        {
            iep = new IPEndPoint(IPAddress.Parse("0.0.0.0"), port);
        }
        #endregion

        #region 公用方法
        /// <summary>
        /// 启动服务器程序,开始监听客户端请求
        /// </summary>
        public void Start()
        {
            session = new Dictionary<EndPoint, TcpTranslate>();
            listener = new TcpListener(iep);
            listener.Start(10);
            //监听客户端连接请求
            listener.BeginAcceptSocket(
                new AsyncCallback(clientConnect), listener);
        }
        private void clientConnect(IAsyncResult ar)
        {
            //接受客户的连接,得连接Socket
            Socket socket = listener.EndAcceptSocket(ar);
            TcpTranslate trans = new TcpTranslate(socket);
            //trans.DisConnect += new NetEvent(trans_DisConnect);
            //开始接受数据
            trans.StartReceive();

            //客户端连接成功事件
            if (Connected != null) Connected(this, trans);
            TcpTranslate.WriteLine(trans.RemoteEndPoint.ToString() + " is Connection...Num" + session.Count.ToString());
            if (session.ContainsKey(trans.RemoteEndPoint))
            {
                session[trans.RemoteEndPoint] = trans;
            }
            else
            {
                session.Add(trans.RemoteEndPoint, trans);
            }
            if (ConnectCount < maxsockets)
            {
                //继续监听客户端连接请求
                listener.BeginAcceptSocket(
                    new AsyncCallback(clientConnect), listener);
            }
            else
            {   //达到最大连接客户数,则关闭监听.
                listener.Stop();
            }
        }

        //客户端断开连接
        void trans_DisConnect(object sender, Socket e)
        {
            //如果已关闭侦听器,则打开,继续监听
            TcpTranslate trans = (TcpTranslate)sender;
            if (ConnectCount == maxsockets)
            {
                listener.Start(1);
                listener.BeginAcceptSocket(
                    new AsyncCallback(clientConnect), listener);
            }
            session.Remove(trans.RemoteEndPoint);
            //触发客户断开事件
            if (DisConnect != null) { DisConnect(this, trans); }
            TcpTranslate.WriteLine(trans.RemoteEndPoint.ToString() + " is DisConnect...Num" + session.Count.ToString());
        }
        #endregion
    }

    #region 传输对象类
    /// <summary>
    /// 传输对象类,接收缓冲区为默认值 8192 个字节。
    /// </summary>
    public class TcpTranslate
    {
        #region 网络事件
        /// <summary>
        /// 连接成功事件
        /// </summary>
        public event NetEvent Connect;
        /// <summary>
        /// 断开连接事件
        /// </summary>
        public event NetEvent DisConnect;
        /// <summary>
        /// 接收到数据事件
        /// </summary>
        public event NetEvent Receive;
        /// <summary>
        /// 接收到文本事件
        /// </summary>
        public event NetEvent ReceiveText;
        /// <summary>
        /// 接收完文件事件
        /// </summary>
        public event NetEvent ReceiveFile;
        /// <summary>
        /// 接收完对象事件
        /// </summary>
        public event NetEvent ReceiveObje;
        #endregion

        #region 字段
        private Socket socket;              // 客户连接类
        private Stream bufferObject;        // 缓存所有接收到的对象数据
        private Stream bufferFile;          // 缓存所有接收到的文件数据
        private int recObjeLen = -1;        // 接收到的对象的长度
        private int recFileLen = -1;        // 接收到的文件的长度
        string filePath = @"c:/temp/";      //文件的保存位置
        string fileName;
        //private List<string> bufferText;  // 缓存所有接收到的文本
        private IPEndPoint iep;

        private bool allowSendText = true;
        private bool allowSendObje = true;
        private bool allowSendFile = true;
        private bool isConnected;

        const int bufferLen = 8192;         //缓存大小
        const int headLen = 4;              //包头大小,用于保存要发送数据的总长度
        const int headLens = 5;             //第一包包头大小
        //包头第一个字节,表示此包所包含的内容
        readonly byte[] textHead = new byte[] { 0 };//文本
        readonly byte[] objeHead = new byte[] { 1 };//对象
        readonly byte[] fileHead = new byte[] { 2 };//文件
        int receiveBigs;                    //接收到的包数
        //int sendBigs;                       //发送的包数
        #endregion

        #region 属性
        public EndPoint RemoteEndPoint
        {
            get { return this.socket.RemoteEndPoint; }
        }
        public bool Connected
        {
            get { return this.socket.Connected; }
        }
        #endregion

        #region 构造函数
        /// <summary>
        /// 服务器端调用此构造函数
        /// </summary>
        /// <param name="socket">Socket成功连接的Socket</param>
        public TcpTranslate(Socket socket)
        {
            this.socket = socket;
            this.socket.ReceiveBufferSize = bufferLen;
            this.isConnected = true;
        }
        /// <summary>
        /// 客户端调用此构造函数
        /// </summary>
        /// <param name="ip">要连接的服务器IP</param>
        /// <param name="port">要连接的端口</param>
        public TcpTranslate(string ip, int port)
        {
            iep = new IPEndPoint(IPAddress.Parse(ip), port);
            this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            this.socket.ReceiveBufferSize = bufferLen;
            this.isConnected = false;
        }
        #endregion

        [System.Diagnostics.Conditional("DUBUG")]
        public static void WriteLine(string message)
        {
            Console.WriteLine(message);
        }
        /// <summary>
        /// 开始接收数据
        /// </summary>
        public void StartReceive()
        {
            if (isConnected)
            {
                byte[] bytes = new byte[bufferLen];
                this.socket.BeginReceive(bytes, 0, bufferLen, SocketFlags.None,
                    new AsyncCallback(ReceivceData), bytes);
            }
            else
            {
                this.socket.BeginConnect(iep, new AsyncCallback(connected), socket);
            }
        }
        private void connected(IAsyncResult iar)
        {
            isConnected = true;
            if (Connect != null) Connect(this, this);
            byte[] bytes = new byte[bufferLen];
            this.socket.BeginReceive(bytes, 0, bytes.Length, SocketFlags.None,
                new AsyncCallback(ReceivceData), bytes);
        }

        /// <summary>
        /// 接收数据回调函数
        /// </summary>
        /// <param name="ar"></param>
        private void ReceivceData(IAsyncResult ar)
        {
            try
            {
                //接收到的数据长度．
                SocketError sErr;
                int receLen = this.socket.EndReceive(ar, out sErr);
                if (receLen > 0)
                {
                    byte[] receBytes = (byte[])ar.AsyncState;
                    switch (receBytes[0])
                    {
                        case 0:     //接收到文本
                            ReceivceText(receLen, receBytes);
                            break;
                        case 1:     //接收到对象
                            ReceivceObje(receLen, receBytes);
                            break;
                        case 2:     //接收到文件
                            ReceivceFile(receLen, receBytes);
                            break;
                        default:    //接收错误
                            WriteLine("错误的数据包: 包头为" + receBytes[0].ToString());
                            WriteLine(sErr.ToString());
                            break;

                    }
                    //继续接收数据
                    byte[] bytes = new byte[bufferLen];
                    this.socket.BeginReceive(bytes, 0, bytes.Length, SocketFlags.None,
                       new AsyncCallback(ReceivceData), bytes);
                    return;
                }
            }
            catch (SocketException socketErr)
            {
                WriteLine(socketErr.Message);
            }
            catch (ObjectDisposedException socketClose)
            {
                WriteLine(socketClose.Message);
            }
            catch (Exception err)
            {
                WriteLine(err.Message);
            }
            //断开连接事件
            if (DisConnect != null) DisConnect(socket, this);
            this.recObjeLen = -1;
            this.recFileLen = -1;
        }

        void ReceivceObje(int receLen, byte[] receBytes)
        {
            //读第一包.得到本次要接收的数据包的总长
            if (recObjeLen == -1 && receLen > headLen)
            {
                this.recObjeLen = Buffer.Bin2Int(new byte[] {
                            receBytes[1], receBytes[2], receBytes[3], receBytes[4] });
                WriteLine("总长度为:"  + recObjeLen.ToString());
                this.bufferObject = new MemoryStream();
                //不只一包(第一包不为最后一包)
                if (this.recObjeLen > bufferLen - headLens)
                {
                    this.bufferObject.Write(receBytes, headLens, receLen - headLens);
                }
                else
                {
                    this.bufferObject.Write(receBytes, headLens, recObjeLen);
                    reObjeEnd();
                }
            }

            //最后一包
            else if (this.bufferObject.Length + (bufferLen - 1) >= this.recObjeLen)
            {
                int lastLen = (int)(this.recObjeLen - this.bufferObject.Length);
                this.bufferObject.Write(receBytes, 1, lastLen);
                reObjeEnd();
            }
            else
            {
                this.bufferObject.Write(receBytes, 1, receLen - 1);
                //接收到数据事件
                if (Receive != null) { Receive(receBytes, this); }
                receiveBigs++;
                WriteLine(receiveBigs.ToString() + "  " + bufferObject.Length.ToString());
            }
        }
        void reObjeEnd()
        {
            object obj;
            lock (bufferObject)
            {
                this.recObjeLen = -1;
                BinaryFormatter formatter = new BinaryFormatter();
                bufferObject.Position = 0;
                obj = formatter.Deserialize(bufferObject);
            }
            //接收完数据事件
            if (ReceiveObje != null) { ReceiveObje(obj, this); }
            WriteLine("对象接收完成  " + obj.GetType().ToString() + "   " + obj.ToString());
        }
        void ReceivceFile(int receLen, byte[] receBytes)
        {
            //读第一包.得到本次要接收的数据包的总长
            if (recFileLen == -1 && receLen > headLen)
            {
                this.recFileLen = Buffer.Bin2Int(new byte[] {
                            receBytes[1], receBytes[2], receBytes[3], receBytes[4] });
                WriteLine("总长度为:" + recFileLen.ToString());
                this.bufferFile = new MemoryStream();
                this.bufferFile.Write(receBytes, headLens, receLen - headLens);
                do
                {
                    fileName = filePath + DateTime.Now.ToFileTime().ToString();
                }
                while (File.Exists(this.fileName));
                this.bufferFile = File.Create(fileName);

                //不只一包
                if (this.recFileLen > bufferLen - headLens)
                {
                    this.bufferFile.Write(receBytes, headLens, receLen - headLens);
                }
                else //第一包为最后一包
                {
                    this.bufferFile.Write(receBytes, headLens, recFileLen);
                    reFileEnd();
                }
            }
            //最后一包
            else if (this.bufferFile.Length + (bufferLen - 1) >= this.recFileLen)  //是否最后一包
            {
                int lastLen = (int)(this.recFileLen - this.bufferFile.Length);
                this.bufferFile.Write(receBytes, 1, lastLen);
                reFileEnd();
            }
            else
            {
                this.bufferFile.Write(receBytes, 1, receLen - 1);
                //接收到数据事件
                if (Receive != null) { Receive(receBytes, this); }
                receiveBigs++;
                WriteLine(receiveBigs.ToString() + "  " + bufferFile.Length.ToString());
            }
        }
        void reFileEnd()
        {
            lock (bufferFile)
            {
                this.recFileLen = -1;
                bufferFile.Close();
            }
            //接收完数据事件
            if (ReceiveFile != null) { ReceiveFile(this.fileName, this); }
            WriteLine("文件接收完成");
        }

        void ReceivceText(int receLen, byte[] receBytes)
        {
            string reStr = Encoding.Default.GetString(receBytes, 1, receLen - 1).TrimEnd('/u0000');
            //接收完数据事件
            if (ReceiveText != null) { ReceiveText(reStr, this); }
            WriteLine(reStr);
        }

        #region 发送数据
        /// <summary>
        /// 发送文本
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public bool SendText(string text)
        {
            if (allowSendText)
            {
                this.allowSendText = false;                                         //禁止发送文本
                Stream stream = new MemoryStream(Encoding.Default.GetBytes(text));  //得到文本的内存流
                StateBig stateBig = new StateBig(textHead, stream);                 //用于格式化流的对象
                byte[] bytes = new byte[bufferLen];                                 //初始化发送包
                if (stateBig.GetData(ref bytes) > 0)                                //向包中填数据
                {
                    this.socket.BeginSend(bytes, 0, bufferLen, SocketFlags.None,     //开始异步发送
                         new AsyncCallback(sendCallback), stateBig);
                }
                else
                {
                    this.socket.Send(new byte[] { });
                    this.allowSendText = true;
                }
                return true;
            }
            return false;
        }
        /// <summary>
        /// 发送对象
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool SendObject(Object obj)
        {
            if (allowSendObje)
            {
                this.allowSendObje = false;                                             //禁止发送对象
                Stream stream = Buffer.GetStream(obj);                                  //得到对象的内存流
                stream.Position = 0;
                StateBig stateBig = new StateBig(objeHead, stream);                     //用于格式化流的对象
                byte[] bytesFrist = new byte[bufferLen - headLen];                      //初始化发送包
                if (stateBig.GetData(ref bytesFrist) > 0)                               //向包中填数据
                {
                    byte[] bytes = new byte[bufferLen];
                    byte[] head = Buffer.Int2Bin((int)stream.Length);                   //构造包头.包头含有发送的数据的大小
                    Array.Copy(bytesFrist, 0, bytes, 0, objeHead.Length);               //复制文件头标识
                    Array.Copy(head, 0, bytes, objeHead.Length, headLen);               //复制要传送的文件的大小标识
                    int headLens = objeHead.Length + head.Length;
                    Array.Copy(bytesFrist, 1, bytes, headLens, bufferLen - headLens);  //复制数据
                    this.socket.BeginSend(bytes, 0, bufferLen, SocketFlags.None,        //开始异步发送
                         new AsyncCallback(sendCallback), stateBig);
                }
                else
                {
                    this.socket.Send(new byte[] { });
                    this.allowSendObje = true;
                }
                return true;
            }
            return false;
        }
        /// <summary>
        /// 发送文件
        /// </summary>
        /// <param name="filePath">文件路径</param>
        /// <returns></returns>
        public bool SendFile(string filePath)
        {
            if (allowSendFile && File.Exists(filePath))
            {
                this.allowSendFile = false;                                             //禁止发送文件
                Stream stream = File.OpenRead(filePath);                                //得到文件流
                stream.Position = 0;
                StateBig stateBig = new StateBig(fileHead, stream);                     //用于格式化流的对象
                byte[] bytesFrist = new byte[bufferLen - headLen];                      //初始化发送包
                if (stateBig.GetData(ref bytesFrist) > 0)                               //向包中填数据
                {
                    byte[] bytes = new byte[bufferLen];
                    byte[] head = Buffer.Int2Bin((int)stream.Length);                   //构造包头.包头含有发送的数据的大小
                    Array.Copy(bytesFrist, 0, bytes, 0, objeHead.Length);               //复制文件头标识
                    Array.Copy(head, 0, bytes, objeHead.Length, headLen);               //复制要传送的文件的大小标识
                    int headLens = objeHead.Length + head.Length;
                    Array.Copy(bytesFrist, 1, bytes, headLens, bufferLen - headLens);   //复制数据
                    this.socket.BeginSend(bytes, 0, bufferLen, SocketFlags.None,        //开始异步发送
                         new AsyncCallback(sendCallback), stateBig);
                }
                else
                {
                    this.socket.Send(new byte[] { });
                    this.allowSendFile = true;
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// 异步发送回调函数
        /// </summary>
        /// <param name="ar">包含要发送的数据流及数据包的包头</param>
        private void sendCallback(IAsyncResult ar)
        {
            StateBig stateBig = (StateBig)ar.AsyncState;                            //得到包含要发送的数据流的对象
            int sent = this.socket.EndSend(ar);
            byte[] bytes = new byte[bufferLen];
            if (stateBig.GetData(ref bytes) > 0)
            {
                this.socket.BeginSend(bytes, 0, bufferLen, SocketFlags.None,
                    new AsyncCallback(sendCallback), stateBig);
            }
            else
            {
                byte headNum = stateBig.BigHead[0];
                switch (headNum)
                {
                    case 0:
                        this.allowSendText = true; break;
                    case 1:
                        this.allowSendObje = true; break;
                    case 2:
                        this.allowSendFile = true; break;
                    default:
                        break;
                }
                stateBig.Close();
            }
        }
        #endregion

        /// <summary>
        /// 从流中读出数据转化为格式化的包.
        /// </summary>
        public class StateBig
        {
            private byte[] bigHead;
            private Stream stream;
            public byte[] BigHead
            {
                get { return bigHead; }
            }
            public Stream Stream
            {
                get { return stream; }
            }
            public StateBig(byte[] bigHead, Stream stream)
            {
                this.bigHead = bigHead;
                this.stream = stream;
                this.stream.Position = 0;
            }
            ~StateBig()
            {
                this.bigHead = null;
                this.stream.Close();
            }
            public int GetData(ref byte[] bytes)
            {
                Array.Copy(bigHead, 0, bytes, 0, bigHead.Length);
                int readNum = stream.Read(bytes, bigHead.Length, bytes.Length - bigHead.Length);
                return readNum;
            }
            public void Close()
            {
                this.bigHead = null;
                this.stream.Close();
            }
        }

    }
    #endregion

    #region INT to BIN
    public class Buffer
    {
        /// <summary>
        /// 将Int转换为Byte[4]
        /// </summary>
        public static byte[] Int2Bin(int intNum)
        {
            byte[] byteNew = new byte[4];
            for (byte i = 0; i < 4; i++)
            {
                byteNew[i] = (byte)(intNum % 256);
                intNum = intNum >> 8;
            }
            return byteNew;
        }
        /// <summary>
        /// 将Byte[4]数组转换为int;
        /// </summary>
        public static int Bin2Int(byte[] bytes)
        {
            int intNum = 0;
            for (byte i = 0; i < 4; i++)
            {
                intNum += bytes[i] << (i * 8);
            }
            return intNum;
        }
        /// <summary>
        /// 将uint转换为Byte[4]
        /// </summary>
        public static byte[] UInt2Bin(uint uintNum)
        {
            byte[] byteNew = new byte[4];
            for (byte i = 0; i < 4; i++)
            {
                byteNew[i] = (byte)(uintNum % 256);
                uintNum = uintNum >> 8;
            }
            return byteNew;
        }
        /// <summary>
        /// 将Byte[4]数组转换为uint;
        /// </summary>
        public static uint Bin2UInt(byte[] bytes)
        {
            uint uintNum = 0;
            for (byte i = 0; i < 4; i++)
            {
                uintNum += (uint)bytes[i] << (i * 8);
            }
            return uintNum;
        }
        public static Stream GetStream(object objData)
        {
            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream objStrean = new MemoryStream();
            formatter.Serialize(objStrean, objData);
            return objStrean;
        }       
    #endregion
    }
}