使用Net类库，实现的基于TCP/IP简单的通讯框架框架（一）

      今天给大家介绍本人构建的基于TCP/IP的通讯框架，只需使用几个简单的类，就可以轻松构建服务器端和客户端应用程序。该框架在通讯中传输的数据可以是任何的基础类型（如：string 、int等简单类型），也可以是自定义的数据类型（根据你使用的需要），下面详细介绍该框架的实现：

 

第一节 框架结构介绍

 

     该框架使用.Net类库的System.Net.Sockets名称空间的Socket 类和TcpListener类为基础实现的，是一个面向连接的通讯框架。

     该框架由3个层次组成，基础层、服务端应用层、客户端应用层，先简要的介绍一下各层的功能：

 

     ◆基础层：

      该层是整个框架的核心，负责从Socket套接字中获取、发送数据，检查连接是否断开，并负责处理数据边界，将数据转换成原来的数据类型。

 

    ◆服务端应用层：

      该层为服务器端提供侦听、接受客户端的连接请求、管理和客户端的连接。

  

    ◆客户端应用层：

      该层提供向服务器端连接，发送和接收数据的功能。

 

 

各层之间的关系如下图所示：

 各层的具体实现将在下一节详细介绍。

 

 第二节 框架的实现

 

      2.1 基础层的实现

           基础层由3个类和两个代理组成，3个类分别为：BaseMessage 、DataManage、MessageDoWith，2个代理类型为：SocketMessageHandle 、ConnectionMessageHandle。

 

           首先介绍这3个类：

           BaseMessage  该类是提供数据在TCP通道中传输的数据类类，所有数据都将通过它的实例对象来传输。类的定义如下图

 

          该类由两个字段组成，即：DataSource和MessageType，这两个字段的作用如下：

DataSource属性的类型是object，该字段用来传输我们需要的数据（可以是简单的类型，也可以是自定义的类型，注意：自定义的类型一定要在该类型上加上[Serializable]属性）。

MessageType属性的类型是short，该字段用来定义我们DataSource传输的数据类型，其值对应的类型由具体应用来定义（例如： 定义 0 为用户登录消息 1 为用户登录成功 2 为用户登录失败 等等）。

      该类的代码如下：

/// <summary> /// 在TCP通道中传输的信息类。 /// </summary> [Serializable] public sealed class BaseMessage { private object data; private short mType; /// <summary> /// 获取或设置消息数据源，注：自定义类型要是使用可序列化标记 /// </summary> public object DataSource { get { return data; } set { data = value; } } /// <summary> /// 获取或设置定义的消息类型，在实际应用中定义。 /// </summary> public short MessageType { get { return mType; } set { mType = value; } } }

 

      DataManage  数据处理类，负责将要将传输的数据（BaseMessage类的实例）消息序号化为二进制数据和将二进制数据反序列化为对象。该类的定义如下图：

 

 

      该类由两个方法组成：Serialize和UnSerialize，这两个方法的功能如下：

Serialize方法的功能是：将传输的数据（BaseMessage类的实例）序列化成二进制数据。

UnSerialize方法的功能是：将接收到的二进制数据反序列化为传输前的数据（BaseMessage类的实例）。

 该类的代码如下：

/// <summary> /// 数据处理类，主要是负责将消息序号化为二进制数据和将二进制数据反序列化为对象。 /// </summary> internal class DataManage { /// <summary> /// 将要发送数据序列化为字节代码 /// </summary> /// <param name="data">序列化对象</param> /// <returns>返回二进制数组</returns> public static byte[] Serialize(BaseMessage data) { IFormatter formatter = new BinaryFormatter(); byte[] buffer = null; using (MemoryStream memStream = new MemoryStream()) { formatter.Serialize(memStream, data); memStream.Position = 0; buffer = new byte[memStream.Length]; memStream.Read(buffer, 0, (int)memStream.Length); memStream.Close(); } return buffer; } /// <summary> /// 将二进制数据反序列化为消息对象。 /// </summary> /// <param name="data"></param> /// <returns></returns> public static bool UnSerialize(byte[] data, List<byte[]> buffers, out BaseMessage baseMessage) { IFormatter formatter = new BinaryFormatter(); using (MemoryStream memStream = new MemoryStream()) { //查询边界，此处为边界的头位置 if (data[0] == 0 && data[1] == 1 && data[2] == 0 && data[3] == 0 && data[4] == 0) buffers.Clear(); foreach (byte[] b in buffers) { memStream.Write(b, 0, b.Length); } memStream.Write(data, 0, data.Length); memStream.Position = 0; try { baseMessage = (BaseMessage)formatter.Deserialize(memStream); return true; } catch /*(SerializationException e)*/ { buffers.Add(data); } memStream.Close(); } baseMessage = null; return false; ; } }

 

    MessageDoWith 该类负责消息的发送和接收，其类图如下：

 

   该类有两个主要方法和两个事件组成，下面介绍一下这两个方法和事件,

   Send方法：用来发送数据，数据是baseManage类的实例。

   ReceiveData方法：接收从Socket套接字发送来的数据，当接收到完整的数据后，发出接收到数据的消息，通知消息处理程序处理。

 

   OnReceiveMessage 事件：在收到完整的消息包，通知消息处理程序处理。

   OnSocketClosed事件：检测到连接已断开，发出连接已断开的通知。

  具体的实现可参与如下的代码：

/// <summary> /// 负责消息的发送和接收 /// </summary> public class MessageDoWith { private Socket _socket; private System.Timers.Timer _timer; private List<byte[]> _buffer = new List<byte[]>(); /// <summary> /// 连接的测试等待时间，单位：毫秒 /// </summary> private int Link_Wait_Time = 2000; /// <summary> /// 收到来自客户消息事件 /// </summary> public event SocketMessageHandle OnReceiveMessage; /// <summary> /// Socket已关闭事件 /// </summary> public event EventHandler OnSocketClosed; public MessageDoWith(Socket socket) { this._socket = socket; _timer = new System.Timers.Timer(); _timer.Interval = 1000; //_timer.Enabled = true; _timer.Elapsed += new System.Timers.ElapsedEventHandler(_timer_Elapsed); } void _timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { if (!this._socket.Connected) { this._timer.Enabled = false; if (this.OnSocketClosed != null) this.OnSocketClosed(this, new EventArgs()); } } public void ReceiveData() { int wait_Time = 0; bool isRun = true; while (isRun) { try { if (this._socket == null) break; System.Threading.Thread.Sleep(20); if (!this._socket.Connected) break; int dLength = this._socket.Available; if (dLength > 0) { byte[] buffer = new byte[dLength]; this._socket.Receive(buffer); BaseMessage n; if (!DataManage.UnSerialize(buffer, this._buffer, out n)) continue; //在此处通知外部处理程序 if (this.OnReceiveMessage != null) this.OnReceiveMessage(this, n); wait_Time = 0; } else { wait_Time += 20; } if (wait_Time >= Link_Wait_Time) { BaseMessage msg = new BaseMessage(); msg.MessageType = -1; msg.DataSource = ""; this.Send(msg ); if (!this._socket.Connected) { isRun = false; break; } wait_Time = 0; } } catch (SocketException se) { if (se.ErrorCode != 10035) { Console.WriteLine(string.Format("sc_SocketException :{0} ErrorCode:{1}", se.Message, se.ErrorCode)); break; } } catch (ObjectDisposedException oe) { this._socket.Close(); Console.WriteLine("sc_ObjectDisposedException :" + oe.Message); //连接已关闭 break; } catch (Exception e) { Console.WriteLine("sc_Exception :" + e.Message + " e.StackTrace: " + e.StackTrace); break; } }//while(true) if (this._socket != null) { this._socket.Close(); if (this.OnSocketClosed != null) this.OnSocketClosed(this, new EventArgs()); } } /// <summary> /// 发送数据 /// </summary> /// <param name="data"></param> private bool SendData(byte[] data) { try { if (this._socket.Blocking) this._socket.Blocking = false; this._socket.Send(data); return true; } catch { } return false; } /// <summary> /// 发送消息 /// </summary> /// <param name="baseMessage"></param> /// <returns></returns> public bool Send(BaseMessage baseMessage) { return this.SendData(DataManage.Serialize(baseMessage)); } }

 

 

       两个代理见代码：

    /// <summary> /// Socket 套接字通道收到的消息代理 /// </summary> /// <param name="socket"></param> /// <param name="baseMessage"></param> public delegate void SocketMessageHandle(MessageDoWith sender, BaseMessage e); /// <summary> /// 连接消息代理 /// </summary> /// <param name="e"></param> public delegate void ConnectionMessageHandle(ServerToClientLink e);

 

 

 

   2.2 服务器端应用层的实现

 

     服务器端应用层由ConnectionListener 和 ServerToClientLink 两个类组成，这两个类的功能介绍如下：

     ConnectionListener 类，服务器端连接侦听器。用来侦听客户端的连接，并接收连接。该类的类图如下：

 

 该类的代码如下：

/// <summary> /// 服务器端连接侦听器。 /// </summary> /// <remarks></remarks> public class ConnectionListener { private TcpListener _tcpLister; private string ipbound = "127.0.0.1"; private int mPort = 8000; /// <summary> /// 接收到一个连接事件 /// </summary> public event ConnectionMessageHandle OnReceviceConnected; /// <summary> /// 连接侦听器已停止。 /// </summary> public event EventHandler OnTcpListenerStoped; /// <summary> /// 连接侦听器构造函数。 /// </summary> /// <param name="serverIP">服务器IP</param> /// <param name="serverPort">服务器端口</param> public ConnectionListener(string serverIP,int serverPort) { this.ipbound = serverIP; this.mPort = serverPort; } /// <summary> /// 启动侦听。 /// </summary> public void Start() { if (this._tcpLister != null) return; IPAddress ip = IPAddress.Any; try { ip = IPAddress.Parse(ipbound); } catch { ipbound = "127.0.0.1"; } try { _tcpLister = new TcpListener(ip, mPort); _tcpLister.Start(); #if DEBUG Console.WriteLine("侦听已启动，等待连接..."); #endif } catch /*(Exception ex)*/ { return; } while (true) { if (this._tcpLister == null) { break; } try { Socket ServerSocketForClient = _tcpLister.AcceptSocket(); ServerToClientLink clk = new ServerToClientLink(ServerSocketForClient); if (this.OnReceviceConnected != null) this.OnReceviceConnected(clk); #if DEBUG Console.WriteLine("已接受了一个连接，时间：" + DateTime.Now.ToString()); #endif } catch { } } if (this.OnTcpListenerStoped != null) this.OnTcpListenerStoped(this, new EventArgs()); } /// <summary> /// 停止侦听 /// </summary> public void Stop() { if (this._tcpLister != null) { this._tcpLister.Stop(); this._tcpLister = null; } } }

 

     ServerToClientLink 类，服务器与客户端的连接类，负责管理客户端与服务器的消息通讯，包括数据的发送和接收。类图如下：

 该类的代码如下：

/// <summary> /// 服务器与客户端的连接类，负责客户端与服务器的消息通讯，包括数据的发送和接收。 /// /// </summary> public class ServerToClientLink : IDisposable { private Socket _socket; Thread _clientThread = null; private MessageDoWith _msgDoWith; /// <summary> /// 收到来自客户消息事件 /// </summary> public event SocketMessageHandle OnReceiveMessage; /// <summary> /// Socket已关闭事件 /// </summary> public event EventHandler OnSocketClosed; /// <summary> /// 客户端连接构造函数 /// </summary> /// <param name="socket"></param> public ServerToClientLink(Socket socket) { this._socket = socket; this._msgDoWith = new MessageDoWith(this._socket); this._msgDoWith.OnReceiveMessage += new SocketMessageHandle(_msgDoWith_OnReceiveMessage); this._msgDoWith.OnSocketClosed += new EventHandler(_msgDoWith_OnSocketClosed); //创建一个线程区处理数据读取和处理问题。 ThreadStart ts = new ThreadStart(this._msgDoWith.ReceiveData); _clientThread = new Thread(ts); //开始线程。 _clientThread.Start(); } void _msgDoWith_OnSocketClosed(object sender, EventArgs e) { //关闭该线程 Console.WriteLine("sc_连接已断开"); if (this.OnSocketClosed != null) this.OnSocketClosed(sender, e); if (this._clientThread != null) this._clientThread.Abort(); } void _msgDoWith_OnReceiveMessage(MessageDoWith sender, BaseMessage e) { if (this.OnReceiveMessage != null) this.OnReceiveMessage(sender, e); } /// <summary> /// 获取连接的基础结构 /// </summary> public Socket getSocket { get { return _socket; } } /// <summary> /// 关闭连接 /// </summary> public void CloseConnection() { this.Dispose(); } /// <summary> /// 发送数据 /// </summary> /// <param name="data"></param> private bool SendData(byte[] data) { try { this._socket.Send(data); return true; } catch { } return false; } /// <summary> /// 发送消息 /// </summary> /// <param name="baseMessage"></param> /// <returns></returns> public bool Send(BaseMessage baseMessage) { return this.SendData(DataManage.Serialize(baseMessage)); } #region IDisposable 成员 public void Dispose() { if (this._socket != null) { this._socket.Close(); this._socket = null; } if (this._clientThread != null) { if (this._clientThread.ThreadState != ThreadState.Aborted) this._clientThread.Abort(); this._clientThread = null; } } #endregion }//end ServerToClientLink

 

 

   2.3 客户端应用层的实现

 

    客户端应用层由ClientToServerLink类组成，该

    类的功能是，客户端向服务器端发出连接请求，连接建立后，可以向服务器发送消息和接收来自服务器的消息。类图如下：

 

 

    

 该类的代码：

public class ClientToServerLink : IDisposable { /// <summary> /// 本地tcp连接对象 /// </summary> private System.Net.Sockets.Socket _socket = null; private Thread _clientThread = null; private MessageDoWith _msgDoWith; /// <summary> /// 是否正在回收资源，true 是，false 否 /// </summary> private bool isDisposable = false; /// <summary> /// 收到来自通道的消息事件 /// </summary> public event SocketMessageHandle OnReceiveMessage; /// <summary> /// Socket已关闭事件 /// </summary> public event EventHandler OnSocketClosed; public ClientToServerLink() { } /// <summary> /// 连接到服务器,返回空串，连接成功，否则返回失败信息 /// </summary> /// <param name="serverIP"></param> /// <param name="serverPort"></param> /// <returns></returns> public string Connection(string serverIP, int serverPort) { try { if (_socket != null) return ""; _socket = this.ConnectSocket(serverIP, serverPort); if (_socket == null) { return "连接失败"; } this._msgDoWith = new MessageDoWith(_socket); this._msgDoWith.OnReceiveMessage += new SocketMessageHandle(_msgDoWith_OnReceiveMessage); this._msgDoWith.OnSocketClosed += new EventHandler(_msgDoWith_OnSocketClosed); //创建一个数据读取和连接监视的线程 ThreadStart ts = new ThreadStart(this._msgDoWith.ReceiveData); _clientThread = new Thread(ts); //开始线程。 _clientThread.Start(); } catch (Exception e) { return e.Message; } return ""; } void _msgDoWith_OnSocketClosed(object sender, EventArgs e) { if (!isDisposable) { this._socket = null; if (this.OnSocketClosed != null) this.OnSocketClosed(sender, e); //关闭该线程 Console.WriteLine("sc_连接已断开"); if (this._clientThread != null) this._clientThread.Abort(); } } void _msgDoWith_OnReceiveMessage(MessageDoWith sender, BaseMessage e) { if (!isDisposable) { if (e.MessageType == -1) return; if (this.OnReceiveMessage != null) this.OnReceiveMessage(sender, e); } } private Socket ConnectSocket(string server, int port) { Socket s = null; IPHostEntry hostEntry = null; hostEntry = Dns.GetHostEntry(server); foreach (IPAddress address in hostEntry.AddressList) { IPEndPoint ipe = new IPEndPoint(address, port); Socket tempSocket = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp); tempSocket.Connect(ipe); if (tempSocket.Connected) { s = tempSocket; break; } else { continue; } } return s; } /// <summary> /// 发送数据 /// </summary> /// <param name="data"></param> private bool SendData(byte[] data) { try { this._socket.Send(data); return true; } catch(Exception e) { throw e; } return false; } /// <summary> /// 发送消息 /// </summary> /// <param name="baseMessage"></param> /// <returns></returns> public bool Send(BaseMessage baseMessage) { return this.SendData(DataManage.Serialize(baseMessage)); } public void Dispose() { this.isDisposable = true; if (this._socket != null) { this._socket.Close(); this._socket = null; } if (this._clientThread != null) { if (this._clientThread.ThreadState != ThreadState.Aborted) this._clientThread.Abort(); this._clientThread = null; } } }

 

 

 框架的结构就介绍到这里，有关使用方法，我将在下一篇文章介绍，需要源码可以发邮件到 wuyb_2004@QQ.COM。