Socket 异步通信

最近在写数据通信的时候用到的东西！希望对大家有帮助

        /// <summary>
        /// 获取或设置服务器IP地址
        /// </summary>
        public string serverIP = "";
        /// <summary>
        /// 获取或设置服务器端口
        /// </summary>
        public int serverPort = 0;
        /// <summary>
        /// 连接对象
        /// </summary>
        private Socket conn = null;
        /// <summary>
        /// 监听连接对象
        /// </summary>
        private Socket listenSocket = null;
        /// <summary>
        /// 是否停止收发数据（true：停止收发；false：可以收发）
        /// </summary>
        private volatile bool stopFlag = true;
        /// <summary>
        /// 是否连接已断开(true:已断开；false：已连接)
        /// </summary>
        public volatile bool isSocketBroken = true;
        private ManualResetEvent allDone = new ManualResetEvent(false);
        /// <summary>
        /// 抛出接收到的数据的事件
        /// </summary>
        public event NetInfoEventHandler.InfoEvent infoEvent;
        /// <summary>
        /// 抛出异常处理的事件
        /// </summary>
        public event ExceptionEventHandler.ExceptionEvent exceptionEvent;

        /// <summary>
        /// 可以重连的次数，默认不重连
        /// </summary>
        public int canReconnectNum = 0;
        /// <summary>
        /// 已经重连的次数
        /// </summary>
        public int ReconnectedNum = 0;

        /// <summary>
        /// 连接成功编码
        /// </summary>
        public static string SUCCESS_CONNECT = "SUCCESS";
        /// <summary>
        /// 连接异常编码
        /// </summary>
        public static string EXCEPTION_CONNECT = "CONNECT";
        /// <summary>
        /// 接收异常编码
        /// </summary>
        public static string EXCEPTION_RECEIVE = "RECEIVE";
        /// <summary>
        /// 发送异常编码
        /// </summary>
        public static string EXCEPTION_SEND = "SEND";
        /// <summary>
        /// 数据内容起始位置
        /// </summary>
        public static int GOOD_PARSER_OFFSET = 8;

        /// <summary>
        /// 写异常log的对象
        /// </summary>
        public WriteLog exceptionMsgLog;
        /// <summary>
        /// 最新接收到的数据
        /// </summary>
        public byte[] read;
        /// <summary>
        /// 最新发送的数据
        /// </summary>
        public byte[] write;
        /// <summary>
        /// 接收数据的任务
        /// </summary>
        private Task receiveDataTask;
        /// <summary>
        ///监听连接的任务
        /// </summary>
        private Task lisenerTask;
        /// <summary>
        /// 数据开始标志
        /// </summary>
        private char DataBeginChar = '{';
        /// <summary>
        /// 数据结束标志
        /// </summary>
        private char DataEndChar = '}';
        /// <summary>
        /// 存放不完整的数据
        /// </summary>
        public byte[] totalReadByte;
        public Socket workSocket = null;

        public Connection()
        {
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="serverIp"></param>
        /// <param name="serverPort"></param>
        /// <param name="errorLog"></param>
        public Connection(string serverIp,int serverPort,WriteLog errorLog)
        {
            this.serverIP = serverIp;
            this.serverPort = serverPort;
            this.exceptionMsgLog = errorLog;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="serverIp"></param>
        /// <param name="serverPort"></param>
        /// <param name="errorLog"></param>
        public Connection(string serverIp, int serverPort,int receiveBufferSize,int sendBufferSize, WriteLog errorLog)
        {
            this.serverIP = serverIp;
            this.serverPort = serverPort;
            this.exceptionMsgLog = errorLog;
            this.read = new byte[receiveBufferSize];
            this.write = new byte[sendBufferSize];
        }

        /// <summary>
        /// 建立连接
        /// </summary>
        /// <returns></returns>
        public bool connect()
        {
            bool ret = false;

            try
            {
                //初始化
                this.conn = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //开始连接
                this.conn.Connect(this.serverIP, this.serverPort);
                //连接成功，状态设置成已连接
                this.isSocketBroken = false;
                //开始接收数据
                this.stopFlag = false;
                if (this.read == null)
                {
                    this.read = new byte[this.conn.ReceiveBufferSize];
                }
                if (this.write == null)
                {
                    this.write = new byte[this.conn.SendBufferSize];
                }
                //异步接收数据
                SocketError socketErr;
                this.conn.BeginReceive(this.read, 0, this.read.Length, SocketFlags.None, out socketErr, new AsyncCallback(ReadCallback), this);
                //启动后台任务同步接收数据
                //this.receiveDataTask = new Task(() => this.syncReceive(this.conn, 0));
                //this.receiveDataTask.Start();
                //allDone.Set();

                //连接处理成功
                onConnectSuccess();
                ret = true;
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(),EXCEPTION_CONNECT);
            }

            return ret;
        }

        /// <summary>
        /// 连接成功的处理
        /// </summary>
        private void onConnectSuccess()
        {
            try
            {
                //把收到的对象转发给外面的事件
                if (this.exceptionEvent != null)
                {
                    exceptionEvent(this, new ExceptionEventHandler("", SUCCESS_CONNECT));
                }
                //重连次数清零
                this.ReconnectedNum = 0;
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
            }
        }

        /// <summary>
        /// 连接出现异常的处理
        /// </summary>
        private void onConnectException(string exceptionInfo,string exceptionCode)
        {
            try 
            {
                //把收到的对象转发给外面的事件
                if (this.exceptionEvent != null)
                {
                    exceptionEvent(this, new ExceptionEventHandler(exceptionInfo, exceptionCode));
                }
                //是否要重连
                if (this.canReconnectNum > 0)
                {
                    if (this.ReconnectedNum < this.canReconnectNum)
                    {
                        this.ReconnectedNum++;
                        if (this.conn != null)
                        {
                            this.disconnect();
                        }
                        this.connect();
                    }
                }
                else
                {
                    this.isSocketBroken = true;
                    if (this.conn != null)
                    {
                        this.disconnect();
                    }
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
            }
        }

        /// <summary>
        /// 接收数据出现异常的处理
        /// </summary>
        private void onReceiveException(string exceptionInfo, string exceptionCode)
        {
            try
            {
                onConnectException(exceptionInfo, exceptionCode);
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
            }
        }

        /// <summary>
        /// 发送数据出现异常的处理
        /// </summary>
        private void onSendException(string exceptionInfo, string exceptionCode)
        {
            try
            {
                onConnectException(exceptionInfo, exceptionCode);
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
            }
        }

        /// <summary>
        /// 建立连接
        /// </summary>
        /// <returns></returns>
        public bool lisenter()
        {
            bool ret = false;

            try
            {
                IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(this.serverIP), this.serverPort);
                this.conn = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                this.conn.Bind(ipe);
                //监听成功，状态设置成已连接
                this.isSocketBroken = false;
                //开始接收数据
                this.stopFlag = false;
                if (this.read == null)
                {
                    this.read = new byte[this.conn.ReceiveBufferSize];
                }
                if (this.write == null)
                {
                    this.write = new byte[this.conn.SendBufferSize];
                }
                //启动后台任务监听连接
                this.lisenerTask = new Task(() => this.startListen());
                this.lisenerTask.Start();
                allDone.Set();

                //连接处理成功
                ret = true;
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
            }

            return ret;
        }

        private void startListen()
        {
            try
            {
                conn.Listen(100);

                while (!stopFlag)
                {
                    allDone.Reset();

                    // Start an asynchronous socket to listen for connections.
                    //Console.WriteLine("Waiting for a connection...");
                    try
                    {
                        conn.BeginAccept(new AsyncCallback(AcceptCallback), conn);
                    }
                    catch (Exception e)
                    {
                        //Console.WriteLine(e.ToString());
                    }

                    // Wait until a connection is made before continuing.
                    allDone.WaitOne();
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
            }
        }

        class ReadSocketState
        {
            public Socket socket;
            public volatile bool isStopFlag;
        }
        private ReadSocketState rss = null;
        public const int DATA_OFFSET = 4;
        public void AcceptCallback(IAsyncResult ar)
        {
            try
            {
                Socket listenSocket = (Socket)ar.AsyncState;
                Socket tempSocket = listenSocket.EndAccept(ar);

                // Signal the main thread to continue.
                allDone.Set();

                Connection newConn = new Connection(listenSocket.AddressFamily.ToString(),0,this.exceptionMsgLog);
                newConn.conn = tempSocket;
                newConn.read = new byte[tempSocket.ReceiveBufferSize];
                newConn.write = new byte[tempSocket.SendBufferSize];
                newConn.isSocketBroken = false;
                newConn.infoEvent += new NetInfoEventHandler.InfoEvent(ClientSocket_infoEvent);
                newConn.exceptionEvent += new ExceptionEventHandler.ExceptionEvent(ClientSocket_ExceptionEvent);
                //异步接收数据
                SocketError socketErr;
                newConn.conn.BeginReceive(newConn.read, 0, newConn.read.Length, SocketFlags.None, out socketErr, new AsyncCallback(ReadCallback), newConn);
                ////启动后台任务同步接收数据
                //Task newTask = new Task(() => newConn.syncReceive(newConn.conn, 0));
                //newTask.Start();
                //newConn.allDone.Set();
                //通知有一个连接连上来了
                if (this.exceptionEvent != null)
                {
                    exceptionEvent(newConn, new ExceptionEventHandler("客户端有新的客户连进来了", SUCCESS_CONNECT));
                }

                //ThreadPool.QueueUserWorkItem(new WaitCallback(syncReceive), rss);
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
            }
            
        }

        public void ReadCallback(IAsyncResult ar)
        {
            Connection con = null;
            try
            {
                con = (Connection)ar.AsyncState;
                Socket socket = con.conn;
                // Read data from the remote device.
                SocketError socketErr;
                int bytesRead = socket.EndReceive(ar, out socketErr);

                string temp = Encoding.UTF8.GetString(con.read);
                if (0 == bytesRead)
                {
                    //errorLogger.log(ZDLogger.LVL_CRITCAL, CLASS_NM, "syncReceive", "Connection is broken!");
                    //throw new SocketException(System.Convert.ToInt32(SocketError.ConnectionReset));
                }
                else
                {
                    if (temp.IndexOf("MARKET") < 0 && temp.IndexOf("TEST") < 0)
                    {
                        this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, temp);
                    }
                    string tmp = con.analyzeData(bytesRead, con);

                    //if (tmp.IndexOf("MARKET") < 0)
                    //{
                    //    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, tmp);
                    //}

                    //转为后台线程处理读取的数据，不阻塞主线程对数据的读取
                    if (!string.IsNullOrEmpty(tmp))
                    {
                        this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, "启动任务前");
                        Task task = new Task(() => do_OneReceiveData(tmp, con));
                        task.Start();
                        this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, "启动任务后");
                    }
                }
                
                //异步接收数据
                //SocketError socketErr;
                con.conn.BeginReceive(con.read, 0, con.read.Length, SocketFlags.None, out socketErr, new AsyncCallback(ReadCallback), con);

            }
            catch (SocketException se)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, se.StackTrace);
                }
                if (con != null)
                {
                    con.onReceiveException(se.StackTrace, EXCEPTION_RECEIVE);
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                if (con != null)
                {
                    con.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
                }
            }
        }

        /// <summary>
        /// 接收到客户端一条数据的处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ClientSocket_infoEvent(Connection sender, NetInfoEventHandler e)
        {
            try
            {
                NetInfo netInfo = e.EventArg;
                //心跳数据不处理
                if (netInfo.code == CommandCode.HEARTBIT)
                {
                    return;
                }
                if (this.infoEvent != null)
                {
                    infoEvent(sender, new NetInfoEventHandler(netInfo));
                }
                
            }
            catch (Exception ex)
            {
                this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
            }
        }

        /// <summary>
        /// 接收到客户端异常的处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ClientSocket_ExceptionEvent(Connection sender, ExceptionEventHandler e)
        {
            try
            {
                string code = e.EventCode;
                string msg = e.EventArg;
                //把收到的对象转发给外面的事件
                if (this.exceptionEvent != null)
                {
                    exceptionEvent(sender, new ExceptionEventHandler(msg, code));
                }
                
            }
            catch (Exception ex)
            {
                this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
            }
        }

        public void syncReceive(object stateObj)
        {
            //ReadSocketState rss = (ReadSocketState)stateObj;
            //Socket socket = rss.socket;
            //try
            //{
            //    DateTime timeBegin = DateTime.Now;

            //    while (true)
            //    {
            //        if (socket == null || this.isSocketBroken)
            //        {
            //            continue;
            //        }

            //        //NetInfo netInfo = readClientRequestMsg(socket, 5000);

            //        if (socket.Poll(3000000, SelectMode.SelectRead)) // one-second timeout
            //        {
            //            int bytesRead = socket.Receive(this.read);
            //            //string temp = Encoding.UTF8.GetString(networkState.readBuffer);
            //            if (0 == bytesRead)
            //            {
            //                //errorLogger.log(ZDLogger.LVL_CRITCAL, CLASS_NM, "syncReceive", "Connection is broken!");
            //                throw new SocketException(System.Convert.ToInt32(SocketError.ConnectionReset));
            //            }
            //            string tmp = this.analyzeData(bytesRead);

            //            //转为后台线程处理读取的数据，不阻塞主线程对数据的读取
            //            if (!string.IsNullOrEmpty(tmp))
            //            {
            //                Task task = new Task(() => this.do_OneReceiveClientData(tmp, socket));
            //                task.Start();
            //            }
            //        }

            //        if (rss.isStopFlag)
            //        {
            //            socket.Close();
            //            break;
            //        }
            //    }
            //}
            //catch (System.ObjectDisposedException ode)
            //{
            //    // this exception means socket_ is already closed when poll() is called
            //    Console.WriteLine(ode.ToString());
            //}
            //catch (Exception ex)
            //{
            //    if (this.exceptionMsgLog != null)
            //    {
            //        this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
            //    }
            //    onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
            //}

        }

        public NetInfo readClientRequestMsg(Socket socket, int timeout)
        {
            try
            {
                byte[] data = syncReceive(socket, timeout);
                // Timeout
                if (data == null) return null;

                string msg = System.Text.ASCIIEncoding.ASCII.GetString(data, GOOD_PARSER_OFFSET, data.Length - GOOD_PARSER_OFFSET);

                //errorLogger.log(ZDLogger.LVL_CRITCAL, msg);

                NetInfo netInfo = new NetInfo();
                netInfo.MyReadString(msg);
                return netInfo;
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
                return null;
            }
            

            
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        /// <returns></returns>
        public bool disconnect()
        {
            bool ret = false;

            try
            {
                //this.conn.Close();
                this.conn.Disconnect(true);
                //连接断开成功，状态设置成已断开
                this.isSocketBroken = true;
                this.stopFlag = true;
                if (this.receiveDataTask != null)
                {
                    this.receiveDataTask.Dispose();
                    this.receiveDataTask = null;
                }
                if (this.lisenerTask != null)
                {
                    this.lisenerTask.Dispose();
                    this.lisenerTask = null;
                }
                allDone.Set();

                //连接断开处理成功
                ret = true;
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
            }

            return ret;
        }

        /// <summary>
        /// 同步接收数据（后台任务处理）
        /// </summary>
        /// <param name="socket"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        private byte[] syncReceive(Socket socket, int timeout)
        {
            try
            {
                DateTime timeBegin = DateTime.Now;
                while (true)
                {
                    if (socket == null || this.isSocketBroken)
                    {
                        continue;
                    }

                    if (socket.Poll(3000000, SelectMode.SelectRead)) // one-second timeout
                    {
                        int bytesRead = socket.Receive(this.read);
                        string temp = Encoding.UTF8.GetString(this.read);
                        if (0 == bytesRead)
                        {
                            //errorLogger.log(ZDLogger.LVL_CRITCAL, CLASS_NM, "syncReceive", "Connection is broken!");
                            throw new SocketException(System.Convert.ToInt32(SocketError.ConnectionReset));
                        }
                        if (temp.IndexOf("MARKET") < 0)
                        {
                            this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, temp);
                        }
                        string tmp = this.analyzeData(bytesRead,this);

                        //if (tmp.IndexOf("MARKET") < 0)
                        //{
                        //    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, tmp);
                        //}
                        
                        //转为后台线程处理读取的数据，不阻塞主线程对数据的读取
                        if (!string.IsNullOrEmpty(tmp))
                        {
                            Task task = new Task(() => do_OneReceiveData(tmp,this));
                            task.Start();
                        }
                    }
                    else
                    {
                        //超时的话退出
                        //if (timeout != 0 && DateTime.Now.Subtract(timeBegin).TotalMilliseconds > timeout)
                            //break;
                    }
                }
            }
            catch (System.ObjectDisposedException ode)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ode.StackTrace);
                }
                this.onReceiveException(ode.StackTrace, EXCEPTION_RECEIVE);
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                this.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
            }

            return null;
        }

        /// <summary>
        /// 处理接收到的完整对象数据
        /// </summary>
        /// <param name="inPut"></param>
        private void do_OneReceiveData(string inPut,Connection conn)
        {
            try
            {
                int fir = inPut.IndexOf('{');
                int sec = inPut.IndexOf('}');
                while (fir != -1 && sec != -1)
                {
                    string obj = inPut.Substring(fir + 1, sec - fir - 1);
                    inPut = inPut.Substring(sec + 1);//删除前面完整对象的字符串
                    //===========================//处理obj
                    fir = obj.IndexOf('(');
                    sec = obj.IndexOf(')');
                    string lenstr = obj.Substring(fir + 1, sec - 1);
                    lenstr = lenstr.Substring(4);
                    int len = int.Parse(lenstr);
                    obj = obj.Substring(sec + 1);//取完整对象的值
                    if (len == obj.Length) //完整正确的对象
                    {
                        NetInfo netInfo = new NetInfo();
                        netInfo.MyReadString(obj);
                        //把收到的对象转发给外面的事件
                        if (infoEvent != null)
                        {
                            conn.infoEvent(conn, new NetInfoEventHandler(netInfo));
                        }
                    }
                    fir = inPut.IndexOf('{');
                    sec = inPut.IndexOf('}');
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
            }
        }

        /// <summary>
        /// 处理接收到客户端请求的完整对象数据
        /// </summary>
        /// <param name="inPut"></param>
        private void do_OneReceiveClientData(string inPut,Connection socket)
        {
            try
            {
                int fir = inPut.IndexOf('{');
                int sec = inPut.IndexOf('}');
                while (fir != -1 && sec != -1)
                {
                    string obj = inPut.Substring(fir + 1, sec - fir - 1);
                    inPut = inPut.Substring(sec + 1);//删除前面完整对象的字符串
                    //===========================//处理obj
                    fir = obj.IndexOf('(');
                    sec = obj.IndexOf(')');
                    string lenstr = obj.Substring(fir + 1, sec - 1);
                    lenstr = lenstr.Substring(4);
                    int len = int.Parse(lenstr);
                    obj = obj.Substring(sec + 1);//取完整对象的值
                    if (len == obj.Length) //完整正确的对象
                    {
                        NetInfo netInfo = new NetInfo();
                        netInfo.MyReadString(obj);
                        //把收到的对象转发给外面的事件
                        if (infoEvent != null)
                        {
                            infoEvent(socket, new NetInfoEventHandler(netInfo));
                        }
                    }
                    fir = inPut.IndexOf('{');
                    sec = inPut.IndexOf('}');
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
            }
        }


        /// <summary>
        /// 解析当前接收的数据块，并将完整的数据返回（没有完整数据返回空）
        /// </summary>
        /// <param name="len"></param>
        /// <returns></returns>
        public string analyzeData(int len,Connection con)
        {
            try
            {
                byte[] bytes = new byte[len];
                List<byte> list = con.read.ToList();
                //移除无效部分
                list.RemoveRange(len, list.Count - len);

                bytes = list.ToArray<byte>().Clone() as byte[];

                Boolean begin = false;
                string inPut = Encoding.UTF8.GetString(bytes);
                Boolean end = inPut.EndsWith(con.DataEndChar.ToString());
                if (inPut.ElementAt(0) == con.DataBeginChar)
                {
                    begin = true;
                }

                if (begin && end)
                {
                    //addByteToTotal(bytes);
                    return inPut;
                }
                else if (end) //处理最后的信息
                {

                    addByteToTotal(bytes);
                    inPut = Encoding.UTF8.GetString(totalReadByte);
                    totalReadByte = null;
                    return inPut;
                }
                else //中间的
                {
                    addByteToTotal(bytes);
                    inPut = Encoding.UTF8.GetString(totalReadByte);
                    int tEnd = inPut.LastIndexOf(con.DataEndChar);
                    string r = "";
                    string l = "";
                    if (tEnd >= 0)
                    {
                        r = inPut.Substring(0, tEnd + 1);
                        l = inPut.Substring(tEnd + 1);
                        if (l.Length > 0)
                        {
                            totalReadByte = Encoding.UTF8.GetBytes(l);
                        }
                    }
                    return r;
                }
            }
            catch(Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                this.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
                return "";
            }
        }

        /// <summary>
        /// 增加一个新读取的字节数组数据到总的字节数组数据中
        /// </summary>
        /// <param name="bytes"></param>
        public void addByteToTotal(byte[] bytes)
        {
            if (bytes == null) return;
            try
            {
                lock (this)
                {
                    //用来存放原来残余的数据
                    byte[] oldData = null;
                    //用来计算残余数据的长度
                    int Count = 0;
                    if (totalReadByte != null)
                    {
                        Count = totalReadByte.Length;
                    }

                    if (Count != 0)
                    {
                        oldData = (byte[])totalReadByte.Clone();
                    }
                    totalReadByte = new byte[Count + bytes.Length];
                    if (Count > 0)
                    {
                        oldData.CopyTo(totalReadByte, 0);
                    }
                    bytes.CopyTo(totalReadByte, Count);
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                this.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
            }
        }
                
        /// <summary>
        /// 发送netinfo数据
        /// </summary>
        /// <param name="obj"></param>
        public void sendNetInfo(NetInfo obj)
        {
            try
            {
                this.sendMsg(CommonFunction.ObjectStringToBytes(obj.MyToString()));
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                this.onSendException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_SEND);
            }
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="data"></param>
        public void sendMsg(byte[] data)
        {
            try
            {
                lock (this.conn)
                {
                    int offset = 0;
                    int size = data.Length;
                    size += offset;
                    while (offset < size)
                    {
                        int count = this.conn.Send(data, offset, size - offset, SocketFlags.None);
                        offset += count;
                    }
                }
            }
            catch (Exception ex)
            {
                if (this.exceptionMsgLog != null)
                {
                    this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
                }
                this.onSendException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_SEND);
            }
        }

        /// <summary>
        /// 接收到一个完整数据的处理，在调用的类中实现这个方法来实现各自的处理逻辑
        /// </summary>
        /// <param name="rawMsg"></param>
        //public abstract void onReceiveData(string data);

        /// <summary>
        /// 接收到一个监听连接发来的完整数据的处理，在调用的类中实现这个方法来实现各自的处理逻辑
        /// </summary>
        /// <param name="rawMsg"></param>
        //public abstract void onReceiveClientData(string data, Socket socket);

        ///// <summary>
        ///// 接收数据出现异常的处理，在调用的类中实现这个方法来实现各自的处理逻辑
        ///// </summary>
        ///// <param name="rawMsg"></param>
        //public abstract void onReceiveDataException();

        ///// <summary>
        ///// 发送数据出现异常的处理，在调用的类中实现这个方法来实现各自的处理逻辑
        ///// </summary>
        ///// <param name="rawMsg"></param>
        //public abstract void onSendDataException();
        ///// <summary>
        ///// 建立连接出现异常的处理，在调用的类中实现这个方法来实现各自的处理逻辑
        ///// </summary>
        ///// <param name="rawMsg"></param>
        //public abstract void onConnectException();