////////////////////////////////////////////////////////////////////////////////////////// /* 标题：在C#中使用异步Socket编程实现TCP网络服务的C/S的通讯构架(一)----基础类库部分 当看到.NET中TcpListener和TcpClient的时候,我非常高兴,那就是我想要的通讯模式 但是使用之后发现它们的力量太单薄了,我们需要一个更好的类库来替代它们. 下面提供了一些类,可以很好的完成Tcp的C/S通讯模式.在本文的第二部分,我将为大家介绍怎么使用它们 主要通过事件来现实整个的功能: 服务器的事件包括: 服务器满 新客户端连接 客户端关闭 接收到数据 客户端使用的事件包括: 已连接服务器 接收到数据 连接关闭 另外为了灵活的处理需求变化,还提供了编码器和报文解析器的实现方法. 注意:该类库没有经过严格的测试,如出现Bug,请发送给我,我会觉得你的整个行为是对我的鼓励和支持. */ ////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// (C)2003-2005 C2217 Studio /// 保留所有权利 /// /// 文件名称: TcpCSFramework.cs /// 文件ID: /// 编程语言: C# /// 文件说明: 提供TCP网络服务的C/S的通讯构架基础类 /// (使用异步Socket编程实现) /// /// 当前版本: 1.1 /// 替换版本: 1.0 /// /// 作者: 邓杨均 /// EMail: dyj057@gmail.com /// 创建日期: 2005-3-9 /// 最后修改日期: 2005-3-17 /// /// 历史修改记录: /// /// 时间: 2005-3-14 /// 修改内容: /// 1.创建Ibms.Net.TcpCSFramework命名空间和添加Session对象. /// 2.修改NetEventArgs类,以适应新添加对象. /// 3.添加了会话退出类型,更适合实际的情况. /// 注意: /// * 强制退出类型是应用程序直接结束,比如通过任务管理器结束 /// 程序或者程序异常退出等,没有执行正常的退出方法而产生的. /// * 正常的退出类型是应用程序执行正常的退出的方法关键在于 /// 需要调用Socket.Shutdown( SocketShutdown.Both )后才调用 /// Socket.Close()方法,而不是直接的调用Socket.Close()方法, /// 如果那样调用将产生强制退出类型. /// /// 时间: 2005-3-16 /// 修改内容: /// 1.创建TcpCli,Coder,DatagramResover对象,把抽象和实现部分分离 /// 2.文件版本修改为1.1,1.0版本仍然保留,更名为: /// TcpCSFramework_v1.0.cs /// 3.在TcpServer中修改自定义的hashtable为系统Hashtable类型 /// /// </summary> using System; using System.Net.Sockets; using System.Net; using System.Text; using System.Diagnostics; using System.Collections; namespace Ibms.Net.TcpCSFramework { /// <summary> /// 网络通讯事件模型委托 /// </summary> public delegate void NetEvent(object sender, NetEventArgs e); /// <summary> /// 提供TCP连接服务的服务器类 /// /// 版本: 1.1 /// 替换版本: 1.0 /// /// 特点: /// 1.使用hash表保存所有已连接客户端的状态，收到数据时能实现快速查找.每当 /// 有一个新的客户端连接就会产生一个新的会话(Session).该Session代表了客 /// 户端对象. /// 2.使用异步的Socket事件作为基础，完成网络通讯功能. /// 3.支持带标记的数据报文格式的识别,以完成大数据报文的传输和适应恶劣的网 /// 络环境.初步规定该类支持的最大数据报文为640K(即一个数据包的大小不能大于 /// 640K,否则服务器程序会自动删除报文数据,认为是非法数据),防止因为数据报文 /// 无限制的增长而倒是服务器崩溃 /// 4.通讯格式默认使用Encoding.Default格式这样就可以和以前32位程序的客户端 /// 通讯.也可以使用U-16和U-8的的通讯方式进行.可以在该DatagramResolver类的 /// 继承类中重载编码和解码函数,自定义加密格式进行通讯.总之确保客户端与服务 /// 器端使用相同的通讯格式 /// 5.使用C# native code,将来出于效率的考虑可以将C++代码写成的32位dll来代替 /// C#核心代码, 但这样做缺乏可移植性,而且是Unsafe代码(该类的C++代码也存在) /// 6.可以限制服务器的最大登陆客户端数目 /// 7.比使用TcpListener提供更加精细的控制和更加强大异步数据传输的功能,可作为 /// TcpListener的替代类 /// 8.使用异步通讯模式,完全不用担心通讯阻塞和线程问题,无须考虑通讯的细节 /// /// 注意: /// 1.部分的代码由Rational XDE生成,可能与编码规范不符 /// /// 原理: /// /// /// 使用用法: /// /// 例子: /// /// </summary> public class TcpSvr { #region 定义字段 /// <summary> /// 默认的服务器最大连接客户端端数据 /// </summary> public const int DefaultMaxClient=100; /// <summary> /// 接收数据缓冲区大小64K /// </summary> public const int DefaultBufferSize = 64*1024; /// <summary> /// 最大数据报文大小 /// </summary> public const int MaxDatagramSize = 640*1024; /// <summary> /// 报文解析器 /// </summary> private DatagramResolver _resolver; /// <summary> /// 通讯格式编码解码器 /// </summary> private Coder _coder; /// <summary> /// 服务器程序使用的端口 /// </summary> private ushort _port; /// <summary> /// 服务器程序允许的最大客户端连接数 /// </summary> private ushort _maxClient; /// <summary> /// 服务器的运行状态 /// </summary> private bool _isRun; /// <summary> /// 接收数据缓冲区 /// </summary> private byte[] _recvDataBuffer; /// <summary> /// 服务器使用的异步Socket类, /// </summary> private Socket _svrSock; /// <summary> /// 保存所有客户端会话的哈希表 /// </summary> private Hashtable _sessionTable; /// <summary> /// 当前的连接的客户端数 /// </summary> private ushort _clientCount; #endregion #region 事件定义 /// <summary> /// 客户端建立连接事件 /// </summary> public event NetEvent ClientConn; /// <summary> /// 客户端关闭事件 /// </summary> public event NetEvent ClientClose; /// <summary> /// 服务器已经满事件 /// </summary> public event NetEvent ServerFull; /// <summary> /// 服务器接收到数据事件 /// </summary> public event NetEvent RecvData; #endregion #region 构造函数 /// <summary> /// 构造函数 /// </summary> /// <param name="port">服务器端监听的端口号</param> /// <param name="maxClient">服务器能容纳客户端的最大能力</param> /// <param name="encodingMothord">通讯的编码方式</param> public TcpSvr( ushort port,ushort maxClient, Coder coder) { _port = port; _maxClient = maxClient; _coder = coder; } /// <summary> /// 构造函数(默认使用Default编码方式) /// </summary> /// <param name="port">服务器端监听的端口号</param> /// <param name="maxClient">服务器能容纳客户端的最大能力</param> public TcpSvr( ushort port,ushort maxClient) { _port = port; _maxClient = maxClient; _coder = new Coder(Coder.EncodingMothord.Default); } // <summary> /// 构造函数(默认使用Default编码方式和DefaultMaxClient(100)个客户端的容量) /// </summary> /// <param name="port">服务器端监听的端口号</param> public TcpSvr( ushort port):this( port, DefaultMaxClient) { } #endregion #region 属性 /// <summary> /// 服务器的Socket对象 /// </summary> public Socket ServerSocket { get { return _svrSock; } } /// <summary> /// 数据报文分析器 /// </summary> public DatagramResolver Resovlver { get { return _resolver; } set { _resolver = value; } } /// <summary> /// 客户端会话数组,保存所有的客户端,不允许对该数组的内容进行修改 /// </summary> public Hashtable SessionTable { get { return _sessionTable; } } /// <summary> /// 服务器可以容纳客户端的最大能力 /// </summary> public int Capacity { get { return _maxClient; } } /// <summary> /// 当前的客户端连接数 /// </summary> public int SessionCount { get { return _clientCount; } } /// <summary> /// 服务器运行状态 /// </summary> public bool IsRun { get { return _isRun; } } #endregion #region 公有方法 /// <summary> /// 启动服务器程序,开始监听客户端请求 /// </summary> public virtual void Start() { if( _isRun ) { throw (new ApplicationException("TcpSvr已经在运行.")); } _sessionTable = new Hashtable(53); _recvDataBuffer = new byte[DefaultBufferSize]; //初始化socket _svrSock = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp ); //绑定端口 IPEndPoint iep = new IPEndPoint( IPAddress.Any, _port); _svrSock.Bind(iep); //开始监听 _svrSock.Listen(5); //设置异步方法接受客户端连接 _svrSock.BeginAccept(new AsyncCallback( AcceptConn ), _svrSock); _isRun = true; } /// <summary> /// 停止服务器程序,所有与客户端的连接将关闭 /// </summary> public virtual void Stop() { if( !_isRun ) { throw (new ApplicationException("TcpSvr已经停止")); } //这个条件语句，一定要在关闭所有客户端以前调用 //否则在EndConn会出现错误 _isRun = false; //关闭数据连接,负责客户端会认为是强制关闭连接 if( _svrSock.Connected ) { _svrSock.Shutdown( SocketShutdown.Both ); } CloseAllClient(); //清理资源 _svrSock.Close(); _sessionTable = null; } /// <summary> /// 关闭所有的客户端会话,与所有的客户端连接会断开 /// </summary> public virtual void CloseAllClient() { foreach(Session client in _sessionTable.Values) { client.Close(); } _sessionTable.Clear(); } /// <summary> /// 关闭一个与客户端之间的会话 /// </summary> /// <param name="closeClient">需要关闭的客户端会话对象</param> public virtual void CloseSession(Session closeClient) { Debug.Assert( closeClient !=null); if( closeClient !=null ) { closeClient.Datagram =null; _sessionTable.Remove(closeClient.ID); _clientCount--; //客户端强制关闭链接 if( ClientClose != null ) { ClientClose(this, new NetEventArgs( closeClient )); } closeClient.Close(); } } /// <summary> /// 发送数据 /// </summary> /// <param name="recvDataClient">接收数据的客户端会话</param> /// <param name="datagram">数据报文</param> public virtual void Send( Session recvDataClient, string datagram ) { //获得数据编码 byte [] data = _coder.GetEncodingBytes(datagram); recvDataClient.ClientSocket.BeginSend( data, 0, data.Length, SocketFlags.None, new AsyncCallback( SendDataEnd ), recvDataClient.ClientSocket ); } #endregion #region 受保护方法 /// <summary> /// 关闭一个客户端Socket,首先需要关闭Session /// </summary> /// <param name="client">目标Socket对象</param> /// <param name="exitType">客户端退出的类型</param> protected virtual void CloseClient( Socket client, Session.ExitType exitType) { Debug.Assert ( client !=null); //查找该客户端是否存在,如果不存在,抛出异常 Session closeClient = FindSession(client); closeClient.TypeOfExit = exitType; if(closeClient!=null) { CloseSession(closeClient); } else { throw( new ApplicationException("需要关闭的Socket对象不存在")); } } /// <summary> /// 客户端连接处理函数 /// </summary> /// <param name="iar">欲建立服务器连接的Socket对象</param> protected virtual void AcceptConn(IAsyncResult iar) { //如果服务器停止了服务,就不能再接收新的客户端 if( !_isRun) { return; } //接受一个客户端的连接请求 Socket oldserver = ( Socket ) iar.AsyncState; Socket client = oldserver.EndAccept(iar); //检查是否达到最大的允许的客户端数目 if( _clientCount == _maxClient ) { //服务器已满,发出通知 if( ServerFull != null ) { ServerFull(this, new NetEventArgs( new Session(client))); } } else { Session newSession = new Session( client ); _sessionTable.Add(newSession.ID, newSession); //客户端引用计数+1 _clientCount ++; //开始接受来自该客户端的数据 client.BeginReceive( _recvDataBuffer,0 , _recvDataBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveData), client); //新的客户段连接,发出通知 if( ClientConn != null ) { ClientConn(this, new NetEventArgs(newSession ) ); } } //继续接受客户端 _svrSock.BeginAccept(new AsyncCallback( AcceptConn ), _svrSock); } /// <summary> /// 通过Socket对象查找Session对象 /// </summary> /// <param name="client"></param> /// <returns>找到的Session对象,如果为null,说明并不存在该回话</returns> private Session FindSession( Socket client ) { SessionId id = new SessionId((int)client.Handle); return (Session)_sessionTable[id]; } /// <summary> /// 接受数据完成处理函数，异步的特性就体现在这个函数中， /// 收到数据后，会自动解析为字符串报文 /// </summary> /// <param name="iar">目标客户端Socket</param> protected virtual void ReceiveData(IAsyncResult iar) { Socket client = (Socket)iar.AsyncState; try { //如果两次开始了异步的接收,所以当客户端退出的时候 //会两次执行EndReceive int recv = client.EndReceive(iar); if( recv == 0 ) { //正常的关闭 CloseClient(client, Session.ExitType.NormalExit); return; } string receivedData = _coder.GetEncodingString( _recvDataBuffer, recv ); //发布收到数据的事件 if(RecvData!=null) { Session sendDataSession= FindSession(client); Debug.Assert( sendDataSession!=null ); //如果定义了报文的尾标记,需要处理报文的多种情况 if(_resolver != null) { if( sendDataSession.Datagram !=null && sendDataSession.Datagram.Length !=0) { //加上最后一次通讯剩余的报文片断 receivedData= sendDataSession.Datagram + receivedData ; } string [] recvDatagrams = _resolver.Resolve(ref receivedData); foreach(string newDatagram in recvDatagrams) { //深拷贝,为了保持Datagram的对立性 ICloneable copySession = (ICloneable)sendDataSession; Session clientSession = (Session)copySession.Clone(); clientSession.Datagram = newDatagram; //发布一个报文消息 RecvData(this,new NetEventArgs( clientSession )); } //剩余的代码片断,下次接收的时候使用 sendDataSession.Datagram = receivedData; if( sendDataSession.Datagram.Length > MaxDatagramSize ) { sendDataSession.Datagram = null; } } //没有定义报文的尾标记,直接交给消息订阅者使用 else { ICloneable copySession = (ICloneable)sendDataSession; Session clientSession = (Session)copySession.Clone(); clientSession.Datagram = receivedData; RecvData(this,new NetEventArgs( clientSession )); } }//end of if(RecvData!=null) //继续接收来自来客户端的数据 client.BeginReceive( _recvDataBuffer, 0, _recvDataBuffer.Length , SocketFlags.None, new AsyncCallback( ReceiveData ), client); } catch(SocketException ex) { //客户端退出 if( 10054 == ex.ErrorCode ) { //客户端强制关闭 CloseClient(client, Session.ExitType.ExceptionExit); } } catch(ObjectDisposedException ex) { //这里的实现不够优雅 //当调用CloseSession()时,会结束数据接收,但是数据接收 //处理中会调用int recv = client.EndReceive(iar); //就访问了CloseSession()已经处置的对象 //我想这样的实现方法也是无伤大雅的. if(ex!=null) { ex=null; //DoNothing; } } } /// <summary> /// 发送数据完成处理函数 /// </summary> /// <param name="iar">目标客户端Socket</param> protected virtual void SendDataEnd(IAsyncResult iar) { Socket client = (Socket)iar.AsyncState; int sent = client.EndSend(iar); } #endregion } /// <summary> /// 提供Tcp网络连接服务的客户端类 /// /// 版本: 1.0 /// 替换版本: /// /// 特征: /// 原理: /// 1.使用异步Socket通讯与服务器按照一定的通讯格式通讯,请注意与服务器的通 /// 讯格式一定要一致,否则可能造成服务器程序崩溃,整个问题没有克服,怎么从byte[] /// 判断它的编码格式 /// 2.支持带标记的数据报文格式的识别,以完成大数据报文的传输和适应恶劣的网 /// 络环境. /// 用法: /// 注意: /// </summary> public class TcpCli { #region 字段 /// <summary> /// 客户端与服务器之间的会话类 /// </summary> private Session _session; /// <summary> /// 客户端是否已经连接服务器 /// </summary> private bool _isConnected = false; /// <summary> /// 接收数据缓冲区大小64K /// </summary> public const int DefaultBufferSize = 64*1024; /// <summary> /// 报文解析器 /// </summary> private DatagramResolver _resolver; /// <summary> /// 通讯格式编码解码器 /// </summary> private Coder _coder; /// <summary> /// 接收数据缓冲区 /// </summary> private byte[] _recvDataBuffer = new byte[DefaultBufferSize]; #endregion #region 事件定义 //需要订阅事件才能收到事件的通知，如果订阅者退出，必须取消订阅 /// <summary> /// 已经连接服务器事件 /// </summary> public event NetEvent ConnectedServer; /// <summary> /// 接收到数据报文事件 /// </summary> public event NetEvent ReceivedDatagram; /// <summary> /// 连接断开事件 /// </summary> public event NetEvent DisConnectedServer; #endregion #region 属性 /// <summary> /// 返回客户端与服务器之间的会话对象 /// </summary> public Session ClientSession { get { return _session; } } /// <summary> /// 返回客户端与服务器之间的连接状态 /// </summary> public bool IsConnected { get { return _isConnected; } } /// <summary> /// 数据报文分析器 /// </summary> public DatagramResolver Resovlver { get { return _resolver; } set { _resolver = value; } } /// <summary> /// 编码解码器 /// </summary> public Coder ServerCoder { get { return _coder; } } #endregion #region 公有方法 /// <summary> /// 默认构造函数,使用默认的编码格式 /// </summary> public TcpCli() { _coder = new Coder( Coder.EncodingMothord.Default ); } /// <summary> /// 构造函数,使用一个特定的编码器来初始化 /// </summary> /// <param name="_coder">报文编码器</param> public TcpCli( Coder coder ) { _coder = coder; } /// <summary> /// 连接服务器 /// </summary> /// <param name="ip">服务器IP地址</param> /// <param name="port">服务器端口</param> public virtual void Connect( string ip, int port) { if(IsConnected) { //重新连接 Debug.Assert( _session !=null); Close(); } Socket newsock= new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint iep = new IPEndPoint( IPAddress.Parse(ip), port); newsock.BeginConnect(iep, new AsyncCallback(Connected), newsock); } /// <summary> /// 发送数据报文 /// </summary> /// <param name="datagram"></param> public virtual void Send( string datagram) { if(datagram.Length ==0 ) { return; } if( !_isConnected ) { throw (new ApplicationException("没有连接服务器，不能发送数据") ); } //获得报文的编码字节 byte [] data = _coder.GetEncodingBytes(datagram); _session.ClientSocket.BeginSend( data, 0, data.Length, SocketFlags.None, new AsyncCallback( SendDataEnd ), _session.ClientSocket); } /// <summary> /// 关闭连接 /// </summary> public virtual void Close() { if(!_isConnected) { return; } _session.Close(); _session = null; _isConnected = false; } #endregion #region 受保护方法 /// <summary> /// 数据发送完成处理函数 /// </summary> /// <param name="iar"></param> protected virtual void SendDataEnd(IAsyncResult iar) { Socket remote = (Socket)iar.AsyncState; int sent = remote.EndSend(iar); Debug.Assert(sent !=0); } /// <summary> /// 建立Tcp连接后处理过程 /// </summary> /// <param name="iar">异步Socket</param> protected virtual void Connected(IAsyncResult iar) { Socket socket = (Socket)iar.AsyncState; socket.EndConnect(iar); //创建新的会话 _session = new Session(socket); _isConnected = true; //触发连接建立事件 if(ConnectedServer != null) { ConnectedServer(this, new NetEventArgs(_session)); } //建立连接后应该立即接收数据 _session.ClientSocket.BeginReceive(_recvDataBuffer, 0, DefaultBufferSize, SocketFlags.None, new AsyncCallback(RecvData), socket); } /// <summary> /// 数据接收处理函数 /// </summary> /// <param name="iar">异步Socket</param> protected virtual void RecvData(IAsyncResult iar) { Socket remote = (Socket)iar.AsyncState; try { int recv = remote.EndReceive(iar); //正常的退出 if(recv ==0 ) { _session.TypeOfExit = Session.ExitType.NormalExit; if(DisConnectedServer!=null) { DisConnectedServer(this, new NetEventArgs(_session)); } return; } string receivedData = _coder.GetEncodingString( _recvDataBuffer,recv ); //通过事件发布收到的报文 if(ReceivedDatagram != null) { //通过报文解析器分析出报文 //如果定义了报文的尾标记,需要处理报文的多种情况 if(_resolver != null) { if( _session.Datagram !=null && _session.Datagram.Length !=0) { //加上最后一次通讯剩余的报文片断 receivedData= _session.Datagram + receivedData ; } string [] recvDatagrams = _resolver.Resolve(ref receivedData); foreach(string newDatagram in recvDatagrams) { //Need Deep Copy.因为需要保证多个不同报文独立存在 ICloneable copySession = (ICloneable)_session; Session clientSession = (Session)copySession.Clone(); clientSession.Datagram = newDatagram; //发布一个报文消息 ReceivedDatagram(this,new NetEventArgs( clientSession )); } //剩余的代码片断,下次接收的时候使用 _session.Datagram = receivedData; } //没有定义报文的尾标记,直接交给消息订阅者使用 else { ICloneable copySession = (ICloneable)_session; Session clientSession = (Session)copySession.Clone(); clientSession.Datagram = receivedData; ReceivedDatagram( this, new NetEventArgs( clientSession )); } }//end of if(ReceivedDatagram != null) //继续接收数据 _session.ClientSocket.BeginReceive(_recvDataBuffer, 0, DefaultBufferSize, SocketFlags.None, new AsyncCallback(RecvData), _session.ClientSocket); } catch(SocketException ex) { //客户端退出 if( 10054 == ex.ErrorCode ) { //服务器强制的关闭连接，强制退出 _session.TypeOfExit = Session.ExitType.ExceptionExit; if(DisConnectedServer!=null) { DisConnectedServer(this, new NetEventArgs(_session)); } } else { throw( ex ); } } catch(ObjectDisposedException ex) { //这里的实现不够优雅 //当调用CloseSession()时,会结束数据接收,但是数据接收 //处理中会调用int recv = client.EndReceive(iar); //就访问了CloseSession()已经处置的对象 //我想这样的实现方法也是无伤大雅的. if(ex!=null) { ex =null; //DoNothing; } } } #endregion } /// <summary> /// 通讯编码格式提供者,为通讯服务提供编码和解码服务 /// 你可以在继承类中定制自己的编码方式如:数据加密传输等 /// </summary> public class Coder { /// <summary> /// 编码方式 /// </summary> private EncodingMothord _encodingMothord; protected Coder() { } public Coder(EncodingMothord encodingMothord) { _encodingMothord = encodingMothord; } public enum EncodingMothord { Default =0, Unicode, UTF8, ASCII, } /// <summary> /// 通讯数据解码 /// </summary> /// <param name="dataBytes">需要解码的数据</param> /// <returns>编码后的数据</returns> public virtual string GetEncodingString( byte [] dataBytes,int size) { switch( _encodingMothord ) { case EncodingMothord.Default: { return Encoding.Default.GetString(dataBytes,0,size); } case EncodingMothord.Unicode: { return Encoding.Unicode.GetString(dataBytes,0,size); } case EncodingMothord.UTF8: { return Encoding.UTF8.GetString(dataBytes,0,size); } case EncodingMothord.ASCII: { return Encoding.ASCII.GetString(dataBytes,0,size); } default: { throw( new Exception("未定义的编码格式")); } } } /// <summary> /// 数据编码 /// </summary> /// <param name="datagram">需要编码的报文</param> /// <returns>编码后的数据</returns> public virtual byte[] GetEncodingBytes(string datagram) { switch( _encodingMothord) { case EncodingMothord.Default: { return Encoding.Default.GetBytes(datagram); } case EncodingMothord.Unicode: { return Encoding.Unicode.GetBytes(datagram); } case EncodingMothord.UTF8: { return Encoding.UTF8.GetBytes(datagram); } case EncodingMothord.ASCII: { return Encoding.ASCII.GetBytes(datagram); } default: { throw( new Exception("未定义的编码格式")); } } } } /// <summary> /// 数据报文分析器,通过分析接收到的原始数据,得到完整的数据报文. /// 继承该类可以实现自己的报文解析方法. /// 通常的报文识别方法包括:固定长度,长度标记,标记符等方法 /// 本类的现实的是标记符的方法,你可以在继承类中实现其他的方法 /// </summary> public class DatagramResolver { /// <summary> /// 报文结束标记 /// </summary> private string endTag; /// <summary> /// 返回结束标记 /// </summary> string EndTag { get { return endTag; } } /// <summary> /// 受保护的默认构造函数,提供给继承类使用 /// </summary> protected DatagramResolver() { } /// <summary> /// 构造函数 /// </summary> /// <param name="endTag">报文结束标记</param> public DatagramResolver(string endTag) { if(endTag == null) { throw (new ArgumentNullException("结束标记不能为null")); } if(endTag == "") { throw (new ArgumentException("结束标记符号不能为空字符串")); } this.endTag = endTag; } /// <summary> /// 解析报文 /// </summary> /// <param name="rawDatagram">原始数据,返回未使用的报文片断, /// 该片断会保存在Session的Datagram对象中</param> /// <returns>报文数组,原始数据可能包含多个报文</returns> public virtual string [] Resolve(ref string rawDatagram) { ArrayList datagrams = new ArrayList(); //末尾标记位置索引 int tagIndex =-1; while(true) { tagIndex = rawDatagram.IndexOf(endTag,tagIndex+1); if( tagIndex == -1 ) { break; } else { //按照末尾标记把字符串分为左右两个部分 string newDatagram = rawDatagram.Substring( 0, tagIndex+endTag.Length); datagrams.Add(newDatagram); if(tagIndex+endTag.Length >= rawDatagram.Length) { rawDatagram=""; break; } rawDatagram = rawDatagram.Substring(tagIndex+endTag.Length, rawDatagram.Length - newDatagram.Length); //从开始位置开始查找 tagIndex=0; } } string [] results= new string[datagrams.Count]; datagrams.CopyTo(results); return results; } } /// <summary> /// 客户端与服务器之间的会话类 /// /// 版本: 1.1 /// 替换版本: 1.0 /// /// 说明: /// 会话类包含远程通讯端的状态,这些状态包括Socket,报文内容, /// 客户端退出的类型(正常关闭,强制退出两种类型) /// </summary> public class Session:ICloneable { #region 字段 /// <summary> /// 会话ID /// </summary> private SessionId _id; /// <summary> /// 客户端发送到服务器的报文 /// 注意:在有些情况下报文可能只是报文的片断而不完整 /// </summary> private string _datagram; /// <summary> /// 客户端的Socket /// </summary> private Socket _cliSock; /// <summary> /// 客户端的退出类型 /// </summary> private ExitType _exitType; /// <summary> /// 退出类型枚举 /// </summary> public enum ExitType { NormalExit , ExceptionExit }; #endregion #region 属性 /// <summary> /// 返回会话的ID /// </summary> public SessionId ID { get { return _id; } } /// <summary> /// 存取会话的报文 /// </summary> public string Datagram { get { return _datagram; } set { _datagram = value; } } /// <summary> /// 获得与客户端会话关联的Socket对象 /// </summary> public Socket ClientSocket { get { return _cliSock; } } /// <summary> /// 存取客户端的退出方式 /// </summary> public ExitType TypeOfExit { get { return _exitType; } set { _exitType = value; } } #endregion #region 方法 /// <summary> /// 使用Socket对象的Handle值作为HashCode,它具有良好的线性特征. /// </summary> /// <returns></returns> public override int GetHashCode() { return (int)_cliSock.Handle; } /// <summary> /// 返回两个Session是否代表同一个客户端 /// </summary> /// <param name="obj"></param> /// <returns></returns> public override bool Equals(object obj) { Session rightObj = (Session)obj; return (int)_cliSock.Handle == (int)rightObj.ClientSocket.Handle; } /// <summary> /// 重载ToString()方法,返回Session对象的特征 /// </summary> /// <returns></returns> public override string ToString() { string result = string.Format("Session:{0},IP:{1}", _id,_cliSock.RemoteEndPoint.ToString()); //result.C return result; } /// <summary> /// 构造函数 /// </summary> /// <param name="cliSock">会话使用的Socket连接</param> public Session( Socket cliSock) { Debug.Assert( cliSock !=null ); _cliSock = cliSock; _id = new SessionId( (int)cliSock.Handle); } /// <summary> /// 关闭会话 /// </summary> public void Close() { Debug.Assert( _cliSock !=null ); //关闭数据的接受和发送 _cliSock.Shutdown( SocketShutdown.Both ); //清理资源 _cliSock.Close(); } #endregion #region ICloneable 成员 object System.ICloneable.Clone() { Session newSession = new Session(_cliSock); newSession.Datagram = _datagram; newSession.TypeOfExit = _exitType; return newSession; } #endregion } /// <summary> /// 唯一的标志一个Session,辅助Session对象在Hash表中完成特定功能 /// </summary> public class SessionId { /// <summary> /// 与Session对象的Socket对象的Handle值相同,必须用这个值来初始化它 /// </summary> private int _id; /// <summary> /// 返回ID值 /// </summary> public int ID { get { return _id; } } /// <summary> /// 构造函数 /// </summary> /// <param name="id">Socket的Handle值</param> public SessionId(int id) { _id = id; } /// <summary> /// 重载.为了符合Hashtable键值特征 /// </summary> /// <param name="obj"></param> /// <returns></returns> public override bool Equals(object obj) { if(obj != null ) { SessionId right = (SessionId) obj; return _id == right._id; } else if(this == null) { return true; } else { return false; } } /// <summary> /// 重载.为了符合Hashtable键值特征 /// </summary> /// <returns></returns> public override int GetHashCode() { return _id; } /// <summary> /// 重载,为了方便显示输出 /// </summary> /// <returns></returns> public override string ToString() { return _id.ToString (); } } /// <summary> /// 服务器程序的事件参数,包含了激发该事件的会话对象 /// </summary> public class NetEventArgs:EventArgs { #region 字段 /// <summary> /// 客户端与服务器之间的会话 /// </summary> private Session _client; #endregion #region 构造函数 /// <summary> /// 构造函数 /// </summary> /// <param name="client">客户端会话</param> public NetEventArgs(Session client) { if( null == client) { throw(new ArgumentNullException()); } _client = client; } #endregion #region 属性 /// <summary> /// 获得激发该事件的会话对象 /// </summary> public Session Client { get { return _client; } } #endregion } } 复制代码