Tcp 数据对象传输接口对象设计

输入是一个对象inputObj，接口对象.Send(inputObj),对端接收之后解包成outputObj（与inputObj应相同），触发onPackageReceive事件

• 事件

public event DataServiceHandler onPackageReceived;//收包事件:

　　  public event DataServiceHandler onPackageSent;//发包事件:
        public event DataServiceHandler onPeerDisconnected;// 失连事件:
        public event DataServiceHandler onSendingException;//发包异常事件;
        public event DataServiceHandler onReceivingException;//收包异常时间;
        public event DataServiceHandler onNotify;//对象通知事件(通知一些状态信息什么的)

• 成员

　　　SetClient()//关联Tcp连接到数据对象传输接口,复位数据对象状态，开始接收线程，允许发

　　　Reset()//复位数据对象状态，开始接收线程，允许发

　　   Stop()//停止接收线程,禁止发

Send()//发送数据对象

 public class draftClass
     {
         #region Structure
         #endregion

         #region Fields
         object locker;
         TcpClient clientObj;
         Messager messager=new Messager();
         Thread recvThread;
         #endregion

         #region Events
         public delegate void DataServiceHandler(string msg,object sender);
         public event DataServiceHandler onPackageReceived;
         public event DataServiceHandler onPackageSent;
         public event DataServiceHandler onPeerDisconnected;
         public event DataServiceHandler onSendingException;
         public event DataServiceHandler onReceivingException;
         public event DataServiceHandler onNotify;
         #endregion

         #region Functions
         public void SetClient(TcpClient tc)
         {
             Stop();
             clientObj = tc;
             StartReceiving();
         }
         public void ReStart()
         {
             SetClient(this.clientObj);
         }
         public void Stop() { lock (recvThread) { recvThread.Abort(); } }

         /// <summary>
         /// 打包msg和数据对象,并发送
         /// </summary>
         /// <param name="msg"></param>
         /// <param name="o"></param>
         public void Send(string msg, object o)
         {
             byte[] m = new byte[];
             Encoding.UTF8.GetBytes(msg).CopyTo(m, );
             byte[] data = ObjectToBytes(o);
             byte[] d = new byte[m.Length + data.Length];
             m.CopyTo(d, );
             data.CopyTo(d, m.Length);

             Send(this.clientObj.GetStream(), d);
         }
         public void StartReceiving()
         {
             Thread t = new Thread(new ThreadStart(Receiving));
             t.Name = "[DataService] Receiving Thread";
             t.Start();
         }

         private void Send(NetworkStream ns, byte[] d)
         {
             lock (this)
             {
                 NetworkStream netStream = ns;
                 byte[] data = new byte[d.Length + ];
                 System.BitConverter.GetBytes(d.Length).CopyTo(data, );
                 d.CopyTo(data, );

                 netStream.Write(data, , data.Length);
             }
         }
         private void Receiving()
         {
             {
                 Console.WriteLine("In Thread({0}),WaitingData", Thread.CurrentThread.ManagedThreadId);
                 NetworkStream ns = clientObj.GetStream();
                 while (IsOnline())
                 {
                     while (ns.DataAvailable)
                     {
 #if DEBUG
                         DateTime start = DateTime.Now;
 #endif
                         //收到的数据为2进制的原始数据,数据交给分发器处理函数
                         byte[] data = ReceiveByteArray(ns);
                         Distributor(data);
 #if DEBUG
                         TimeSpan ts = DateTime.Now - start;
                         double r = data.Length *  / (ts.TotalSeconds *  * );
                         Console.WriteLine("ReceiveByteArray Length={0}\tDuring={1:f0}ms\tRate= {2:f3} Mbps", data.Length, ts.TotalMilliseconds, r);
 #endif
                     }
                     //Thread.Sleep(3);
                 }
                 Console.WriteLine("In Thread({0}),clientObj Disconnect!", Thread.CurrentThread.ManagedThreadId);

                 if (onPeerDisconnected != null)
                     onPeerDisconnected("Peer Disconnected",null);
                 Thread.CurrentThread.Abort();
             }
         }
         //报文结构是自定义的2进制数据
         //Part1：定长100字节，存放消息
         //Part2：序列化了的数据对象
         private void Distributor(byte[] data)
         {
             //解包
             string msg = GetMsg(data);
             object obj = GetObj(data);

             //msg过Messager.Paser()
             if (messager.TryParser(msg, obj))
                 return;

             //如果Messager处理失败，触发onPackageReceived事件
             if (onPackageReceived != null)
                 onPackageReceived("",data);
         }
         #region api
         private string GetMsg(byte[] data) { return ""; }
         private object GetObj(byte[] data) {return new object(); }
         private byte[] ReceiveByteArray(NetworkStream stream)
         {
             try
             {
                 int bufferlen = GetSize(stream);
                 byte[] resultbyte = new byte[bufferlen];

                 int offset = , bytesread = ;
                 while (offset < bufferlen)
                 {
                     bytesread = stream.Read(resultbyte, offset, bufferlen - offset);
                     if (bytesread == )
                     {
                         Console.WriteLine("?????A");
                         throw new Exception("网络异常断开，数据读取不完整。");
                     }
                     else
                         offset += bytesread;
                 }
                 return resultbyte;
             }
             catch (Exception)
             {
                 Console.WriteLine("?????B");
                 throw;
             }
         }
         private int GetSize(NetworkStream stream)
         {
             try
             {
                 int bufferlen = ;
                 byte[] resultbyte = new byte[bufferlen];

                 int offset = , bytesread = ;
                 while (offset < bufferlen)
                 {
                     bytesread = stream.Read(resultbyte, offset, bufferlen - offset);
                     if (bytesread == )
                         throw new Exception("网络异常断开，数据读取不完整。");
                     else
                         offset += bytesread;
                 }
                 return System.BitConverter.ToInt32(resultbyte, );
             }
             catch (Exception)
             {
                 throw;
             }
         }
         private bool IsOnline()
         {
             TcpClient c = this.clientObj;
             return !((c.Client.Poll(, SelectMode.SelectRead) && (c.Client.Available == )) || !c.Client.Connected);
         }
         /// <summary>
         /// 将一个object对象序列化，返回一个byte[]
         /// </summary>
         /// <param name="obj">能序列化的对象</param>
         /// <returns></returns>
         ///
         private byte[] ObjectToBytes(object obj)
         {
             using (MemoryStream ms = new MemoryStream())
             {
                 IFormatter formatter = new BinaryFormatter(); formatter.Serialize(ms, obj); return ms.GetBuffer();
             }
         }
         /// <summary>
         /// 将一个序列化后的byte[]数组还原
         /// </summary>
         /// <param name="Bytes"></param>
         /// <returns></returns>
         private object BytesToObject(byte[] Bytes)
         {
             using (MemoryStream ms = new MemoryStream(Bytes))
             {
                 IFormatter formatter = new BinaryFormatter(); return formatter.Deserialize(ms);
             }
         }
         #endregion
         #endregion
     }

DataService.cs