欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  后端开发

c#异步Socket Tcp服务器实现

程序员文章站 2022-04-21 11:34:38
...
使用的是TcpListener来实现的异步服务器

代码

服务器核心代码 AsyncServer.cs

///   
    /// 异步SOCKET 服务器  
    ///   
    public class AsyncServer : IDisposable  
    {  
  
        #region Fields  
        ///   
        /// 服务器程序允许的最大客户端连接数  
        ///   
        private int _maxClient;  
   
        ///   
        /// 当前的连接的客户端数  
        ///   
        private int _clientCount;  
   
        ///   
        /// 服务器使用的异步socket  
        ///   
        private Socket _serverSock;  
   
        ///   
        /// 客户端会话列表  
        ///   
        private List _clients;  
   
        private bool disposed = false;  
  
        #endregion  
  
  
        #region Properties  
   
        ///   
        /// 服务器是否正在运行  
        ///   
        public bool IsRunning { get; private set; }  
        ///   
        /// 监听的IP地址  
        ///   
        public IPAddress Address { get; private set; }  
        ///   
        /// 监听的端口  
        ///   
        public int Port { get; private set; }  
        ///   
        /// 通信使用的编码  
        ///   
        public Encoding Encoding { get; set; }  
          
  
        #endregion  
  
        #region Ctors  
   
        ///   
        /// 异步Socket TCP服务器  
        ///   
        /// 监听的端口  
        public AsyncServer(int listenPort)  
            : this(IPAddress.Any, listenPort,1024)  
        {  
        }  
   
        ///   
        /// 异步Socket TCP服务器  
        ///   
        /// 监听的终结点  
        public AsyncServer(IPEndPoint localEP)  
            : this(localEP.Address, localEP.Port,1024)  
        {  
        }  
   
        ///   
        /// 异步Socket TCP服务器  
        ///   
        /// 监听的IP地址  
        /// 监听的端口  
        /// 最大客户端数量  
        public AsyncServer(IPAddress localIPAddress, int listenPort,int maxClient)  
        {  
            this.Address = localIPAddress;  
            this.Port = listenPort;  
            this.Encoding = Encoding.Default;  
   
            _maxClient = maxClient;  
            _clients = new List();  
            _serverSock = new Socket(localIPAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
        }  
  
        #endregion  
  
  
        #region Server  
   
        ///   
        /// 启动服务器  
        ///   
        /// 异步TCP服务器  
        public AsyncServer Start()  
        {  
            if (!IsRunning)  
            {  
                IsRunning = true;  
                _serverSock.Bind(new IPEndPoint(this.Address, this.Port));  
                _serverSock.Listen(1024);  
                _serverSock.BeginAccept(new AsyncCallback(HandleAcceptConnected), _serverSock);  
            }  
            return this;  
        }  
   
        ///   
        /// 启动服务器  
        ///   
        ///   
        /// 服务器所允许的挂起连接序列的最大长度  
        ///   
        /// 异步TCP服务器  
        public AsyncServer Start(int backlog)  
        {  
            if (!IsRunning)  
            {  
                IsRunning = true;  
                _serverSock.Bind(new IPEndPoint(this.Address, this.Port));  
                _serverSock.Listen(backlog);  
                _serverSock.BeginAccept(new AsyncCallback(HandleAcceptConnected), _serverSock);  
            }  
            return this;  
        }  
   
        ///   
        /// 停止服务器  
        ///   
        /// 异步TCP服务器  
        public AsyncServer Stop()  
        {  
            if (IsRunning)  
            {  
                IsRunning = false;  
                _serverSock.Close();  
                //TODO 关闭对所有客户端的连接  
   
            }  
            return this;  
        }  
  
        #endregion  
  
        #region Receive  
        ///   
        /// 处理客户端连接  
        ///   
        ///   
        private void HandleAcceptConnected(IAsyncResult ar)  
        {  
            if (IsRunning)  
            {  
                Socket server = (Socket)ar.AsyncState;  
                Socket client = server.EndAccept(ar);  
                   
                //检查是否达到最大的允许的客户端数目  
                if (_clientCount == _maxClient)  
                {  
                    //TODO 触发事件  
                    RaiseServerException(null);  
                }  
                else 
                {  
                    Session session = new Session(client);  
                    lock (_clients)  
                    {  
                        _clients.Add(session);  
                        _clientCount++;  
                        RaiseClientConnected(session); //触发客户端连接事件  
                    }  
                    session.RecvDataBuffer = new byte[client.ReceiveBufferSize];  
                    //开始接受来自该客户端的数据  
                    client.BeginReceive(session.RecvDataBuffer, 0, session.RecvDataBuffer.Length, SocketFlags.None,  
                     new AsyncCallback(HandleDataReceived), session);  
                }  
                //接受下一个请求  
                server.BeginAccept(new AsyncCallback(HandleAcceptConnected), ar.AsyncState);  
            }  
        }  
        ///   
        /// 处理客户端数据  
        ///   
        ///   
        private void HandleDataReceived(IAsyncResult ar)  
        {  
            if (IsRunning)  
            {  
                Session session = (Session)ar.AsyncState;  
                Socket client = session.ClientSocket;  
                try 
                {  
                    //如果两次开始了异步的接收,所以当客户端退出的时候  
                    //会两次执行EndReceive  
                    int recv = client.EndReceive(ar);  
                    if (recv == 0)  
                    {  
                        //TODO 触发事件 (关闭客户端)  
                        CloseSession(session);  
                        RaiseNetError(session);  
                        return;  
                    }  
                    //TODO 处理已经读取的数据 ps:数据在session的RecvDataBuffer中  
                    RaiseDataReceived(session);  
                    //TODO 触发数据接收事件  
                }  
                catch (SocketException ex)  
                {  
                    //TODO 异常处理  
                    RaiseNetError(session);  
                }  
                finally 
                {  
                    //继续接收来自来客户端的数据  
                    client.BeginReceive(session.RecvDataBuffer, 0, session.RecvDataBuffer.Length, SocketFlags.None,  
                     new AsyncCallback(HandleDataReceived), session);  
                }  
            }  
        }  
        #endregion  
  
        #region Send  
        ///   
        /// 发送数据  
        ///   
        /// 接收数据的客户端会话  
        /// 数据报文  
        public void Send(Session session, byte[] data)  
        {  
            Send(session.ClientSocket,data);  
        }  
   
        ///   
        /// 异步发送数据至指定的客户端  
        ///   
        /// 客户端  
        /// 报文  
        public void Send(Socket client, byte[] data)  
        {  
            if (!IsRunning)  
                throw new InvalidProgramException("This TCP Scoket server has not been started.");  
   
            if (client == null)  
                throw new ArgumentNullException("client");  
   
            if (data == null)  
                throw new ArgumentNullException("data");  
            client.BeginSend(data, 0, data.Length, SocketFlags.None,  
             new AsyncCallback(SendDataEnd), client);  
        }  
   
        ///   
        /// 发送数据完成处理函数  
        ///   
        /// 目标客户端Socket  
        private void SendDataEnd(IAsyncResult ar)  
        {  
            ((Socket)ar.AsyncState).EndSend(ar);  
        }  
        #endregion  
  
        #region Events  
        ///   
        /// 接收到数据事件  
        ///   
        public event EventHandler DataReceived;  
   
        private void RaiseDataReceived(Session session)  
        {  
            if (DataReceived != null)  
            {  
                DataReceived(this, new AsyncEventArgs(session));  
            }  
        }  
   
        ///   
        /// 与客户端的连接已建立事件  
        ///   
        public event EventHandler ClientConnected;  
        ///   
        /// 与客户端的连接已断开事件  
        ///   
        public event EventHandler ClientDisconnected;  
   
        ///   
        /// 触发客户端连接事件  
        ///   
        ///   
        private void RaiseClientConnected(Session session)  
        {  
            if (ClientConnected != null)  
            {  
                ClientConnected(this, new AsyncEventArgs(session));  
            }  
        }  
        ///   
        /// 触发客户端连接断开事件  
        ///   
        ///   
        private void RaiseClientDisconnected(Socket client)  
        {  
            if (ClientDisconnected != null)  
            {  
                ClientDisconnected(this, new AsyncEventArgs("连接断开"));  
            }  
        }  
        ///   
        /// 网络错误事件  
        ///   
        public event EventHandler NetError;  
        ///   
        /// 触发网络错误事件  
        ///   
        ///   
        private void RaiseNetError(Session session)  
        {  
            if (NetError != null)  
            {  
                NetError(this, new AsyncEventArgs(session));  
            }  
        }  
   
        ///   
        /// 异常事件  
        ///   
        public event EventHandler ServerException;  
        ///   
        /// 触发异常事件  
        ///   
        ///   
        private void RaiseServerException(Session session)  
        {  
            if (ServerException != null)  
            {  
                ServerException(this, new AsyncEventArgs(session));  
            }  
        }  
        #endregion  
  
  
        #region Close  
        ///   
        /// 关闭一个与客户端之间的会话  
        ///   
        /// 需要关闭的客户端会话对象  
        public void CloseSession(Session session)  
        {  
            if (session != null)  
            {  
                session.Datagram = null;  
                session.RecvDataBuffer = null;  
   
                _clients.Remove(session);  
                _clientCount--;  
                //TODO 触发关闭事件  
                session.Close();  
            }  
        }  
        ///   
        /// 关闭所有的客户端会话,与所有的客户端连接会断开  
        ///   
        public void CloseAllClient()  
        {  
            foreach (Session client in _clients)  
            {  
                CloseSession(client);  
            }  
            _clientCount = 0;  
            _clients.Clear();  
        }  
   
        ///   
        /// Performs application-defined tasks associated with freeing,   
        /// releasing, or resetting unmanaged resources.  
        ///   
        public void Dispose()  
        {  
            Dispose(true);  
            GC.SuppressFinalize(this);  
        }  
   
        ///   
        /// Releases unmanaged and - optionally - managed resources  
        ///   
        /// 
true to release   
        /// both managed and unmanaged resources; false   
        /// to release only unmanaged resources.  
        protected virtual void Dispose(bool disposing)  
        {  
            if (!this.disposed)  
            {  
                if (disposing)  
                {  
                    try 
                    {  
                        Stop();  
                        if (_serverSock != null)  
                        {  
                            _serverSock = null;  
                        }  
                    }  
                    catch (SocketException ex)  
                    {  
                        //TODO  
                        RaiseServerException(null);  
                    }  
                }  
                disposed = true;  
            }  
        }  
        #endregion  
    }

其中使用了一个Session类,来封装对客户端的连接

Session,cs

///   
    /// 客户端与服务器之间的会话类  
    ///   
    public class Session  
    {  
        #region 字段  
        ///   
        /// 接收数据缓冲区  
        ///   
        private byte[] _recvBuffer;  
   
        ///   
        /// 客户端发送到服务器的报文  
        /// 注意:在有些情况下报文可能只是报文的片断而不完整  
        ///   
        private string _datagram;  
   
        ///   
        /// 客户端的Socket  
        ///   
        private Socket _clientSock;  
  
        #endregion  
  
        #region 属性  
   
        ///   
        /// 接收数据缓冲区   
        ///   
        public byte[] RecvDataBuffer  
        {  
            get 
            {  
                return _recvBuffer;  
            }  
            set 
            {  
                _recvBuffer = value;  
            }  
        }  
   
        ///   
        /// 存取会话的报文  
        ///   
        public string Datagram  
        {  
            get 
            {  
                return _datagram;  
            }  
            set 
            {  
                _datagram = value;  
            }  
        }  
   
        ///   
        /// 获得与客户端会话关联的Socket对象  
        ///   
        public Socket ClientSocket  
        {  
            get 
            {  
                return _clientSock;  
   
            }  
        }  
  
  
        #endregion  
   
        ///   
        /// 构造函数  
        ///   
        /// 会话使用的Socket连接  
        public Session(Socket cliSock)  
        {  
   
            _clientSock = cliSock;  
        }  
        ///   
        /// 关闭会话  
        ///   
        public void Close()  
        {  
   
            //关闭数据的接受和发送  
            _clientSock.Shutdown(SocketShutdown.Both);  
   
            //清理资源  
            _clientSock.Close();  
        }  
    }

事件类

class AsyncEventArgs : EventArgs  
    {  
        ///   
        /// 提示信息  
        ///   
        public string _msg;  
   
        public Session _sessions;  
   
        ///   
        /// 是否已经处理过了  
        ///   
        public bool IsHandled { get; set; }  
   
        public AsyncEventArgs(string msg)  
        {  
            this._msg = msg;  
            IsHandled = false;  
        }  
        public AsyncEventArgs(Session session)  
        {  
            this._sessions = session;  
            IsHandled = false;  
        }  
        public AsyncEventArgs(string msg, Session session)  
        {  
            this._msg = msg;  
            this._sessions = session;  
            IsHandled = false;  
        }  
    }