通用通信模型的TCP服务端实现完善

最新推荐文章于 2022-04-29 08:43:24 发布
最新推荐文章于 2022-04-29 08:43:24 发布
阅读量1.1k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gongbenwen/article/details/40182271
版权

上一篇中的实现没有利用好通信工厂进行整合处理，这一篇中重新对通信工厂进行了处理，增加了应答数据的泛型处理，这样所有的应答数据，更加灵活可靠。

通过对通信端口参数的解耦，避免了通信参数与具体的启动类型的二义性。

增加了输入数据处理消息构造器注入和请求数据注入，修改了异步应答的回调处理。

上干货，主要代码实现：

通信工厂：

/// <summary>
    /// 通信工厂构建
    /// </summary>
    /// <typeparam name="TInputMessageFilter">输入消息构造器类型</typeparam>
    /// <typeparam name="TOutputMessageFilter">应答消息过滤器类型</typeparam>
    /// <typeparam name="TRequest">请求数据</typeparam>
    /// <typeparam name="TResponse">应答数据</typeparam>
    public class CommunicationFactory<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse>
        where TInputMessageFilter : BaseInPutMessageFilter<TRequest>
        where TOutputMessageFilter : BaseOutPutMessageFilter<TRequest, TResponse>
        where TRequest : IRequestData
        where TResponse : IResponseData
    {
        /// <summary>
        /// 通信工厂构建
        /// </summary>
        /// <param name="paramerters">通信启动设置参数</param>
        /// <returns>
        /// 返回通信对象
        /// </returns>
        public static ICommunication<TRequest, TResponse> Create(BaseCommunicationParamerters paramerters)
        {
            ICommunication<TRequest, TResponse> iCommunication = null;
            if (paramerters is SerialParamertercs)
            {
                SerialParamertercs tempParamerters = (SerialParamertercs)paramerters;
                iCommunication = new SerialPortCommunication<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse>(tempParamerters.PortName, tempParamerters.BaudRate);
            }
            else if (paramerters is TCPClientParamertercs)
            {
                TCPClientParamertercs tempParamerters = (TCPClientParamertercs)paramerters;
                iCommunication = new TCPClientCommunication<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse>(tempParamerters.Ip, tempParamerters.PortNO);
            }
            else if (paramerters is TCPServerParamertercs)
            {
                TCPServerParamertercs tempParamerters = (TCPServerParamertercs)paramerters;
                iCommunication = new TCPServerCommunication<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse>(tempParamerters.Ip, tempParamerters.PortNO);
            }
            else if (paramerters is TCPHostServerParamertercs)
            {
                TCPHostServerParamertercs tempParamerters = (TCPHostServerParamertercs)paramerters;
                iCommunication = new TCPHostSingleServerCommunication<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse>(tempParamerters.Ip, tempParamerters.PortNO);
            }
            else if (paramerters is TCPAsyncServerParamertercs)
            {
                TCPAsyncServerParamertercs tempParamerters = (TCPAsyncServerParamertercs)paramerters;
                iCommunication = new TCPAsyncServerCommunication<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse>(tempParamerters.Ip, tempParamerters.PortNO);
            }
            if (iCommunication != null)
            {
                IOutPutMessageFilter<TRequest, TResponse> messageFilter = (IOutPutMessageFilter<TRequest, TResponse>)Activator.CreateInstance<TOutputMessageFilter>();
                iCommunication.InitCommunication(paramerters);
            }
            return iCommunication;
        }
    }


通信接口类：

  /// <summary>
    /// 通信接口
    /// </summary>
    /// <typeparam name="TRequest">请求数据类型</typeparam>
    /// <typeparam name="TResponse">应答数据类型</typeparam>
    public interface ICommunication<TRequest,TResponse> 
        where TRequest:IRequestData 
        where TResponse : IResponseData
    {
        /// <summary>
        /// 通信端口初始化
        /// </summary>
        /// <param name="communicationParamertes">通信端口初始化</param>
        void InitCommunication(BaseCommunicationParamerters communicationParamerters);
        /// <summary>
        /// 启动
        /// 如果打开失败，会自动尝试关闭掉
        /// </summary>
        void Open();
        /// <summary>
        /// 是否开启
        /// </summary>
        bool IsOpen { get; }
        /// <summary>
        /// 请求发送
        /// </summary>
        /// <param name="request">请求发送的数据</param>
        void Request(TRequest request);
        /// <summary>
        /// 异步请求数据，在其他线程上
        /// </summary>
        /// <param name="request">请求发送的数据</param>
        void ASyncRequest(TRequest request);
        /// <summary>
        /// 请求数据，根据会话ID发送，
        /// 一般用于并发处理场合，根据ID来确认具体的发送会话，
        /// 用于服务监听应答场合
        /// </summary>
        /// <param name="sessionID">会话ID</param>
        /// <param name="request">请求发送的数据</param>
        void Request(Guid sessionID,TRequest request);
        /// <summary>
        /// 请求等待应答数据
        /// </summary>
        /// <param name="request">请求数据</param>
        /// <param name="timeOut">请求超时时间，单位是毫秒</param>
        /// <returns>
        /// 返回响应数据
        /// </returns>
        TResponse RequestWait(TRequest request, int timeOut = 500);
        /// <summary>
        /// 异步请求等待应答数据
        /// 异步线程上消息队列响应
        /// </summary>
        /// <param name="request">异步请求数据</param>
        void AsyncRequestWait(AsyncRequestWaitHandler<TRequest, TResponse> asyncRequestWait, TRequest requestData);
        /// <summary>
        /// 数据应答
        /// 异步线程上消息队列响应
        /// </summary>
        event ResponseHandler<TResponse> OnResponseBuffer;
        /// <summary>
        /// 异常信息响应
        /// 异步线程上消息队列响应
        /// </summary>
        event ExceptionHandler<Exception> OnException;
        /// <summary>
        /// 普通信息通知
        /// 异步线程上消息队列响应
        /// </summary>
        event ExceptionHandler<string> OnInfo;
        /// <summary>
        /// 打开前触发
        /// </summary>
        event ResponseHandler<bool> OnOpening;
        /// <summary>
        /// 打开后触发
        /// </summary>
        event ResponseHandler<bool> OnOpened;
        /// <summary>
        /// 会话构建后触发
        /// </summary>
        event SessionHandler<TRequest,TResponse> OnSessionAdded;
        /// <summary>
        /// 关闭前触发
        /// </summary>
        event ResponseHandler<bool> OnClosing;
        /// <summary>
        /// 关闭后触发
        /// </summary>
        event ResponseHandler<bool> OnClosed;
        /// <summary>
        /// 关闭
        /// </summary>
        void Close();
    }




通信接口抽象实现类，还是实现各种调用的业务整合：

  /// <summary>
    /// 通信基类
    /// </summary>
    /// <typeparam name="TRequest">请求数据类型</typeparam>
    /// <typeparam name="TResponse">应答数据类型</typeparam>
    internal abstract class BaseCommunication<TRequest,TResponse> 
        : ICommunication<TRequest,TResponse>
        where TRequest : IRequestData
        where TResponse : IResponseData
    {
        /// <summary>
        /// 响应处理消息队列，用于应答排队
        /// </summary>
        private IoCompletionMessageFIFO responseMessageFIFO = null;
        /// <summary>
        /// 启动
        /// 如果打开失败，会自动尝试关闭掉
        /// </summary>
        public abstract void Open();
        /// <summary>
        /// 是否开启
        /// </summary>
        public bool IsOpen
        {
            get
            {
                if (responseMessageFIFO == null)
                {
                    return false;
                }
                return responseMessageFIFO.IsOpened;
            }
        }
        /// <summary>
        /// 关闭
        /// </summary>
        public abstract void Close();
        /// <summary>
        /// 初始化设备通信端口参数
        /// </summary>
        /// <param name="communicationParamertes">设备通信端口初始化参数</param>
        public abstract void InitCommunication(BaseCommunicationParamerters communicationParamerters);
        #region 请求写入数据
        /// <summary>
        /// 请求发送的数据
        /// </summary>
        /// <param name="data">请求数据</param>
        public virtual void Request(TRequest data)
        {
            throw new Exception(string.Format("{0}不支持Request的调用", this.GetType().FullName));
        }
        /// <summary>
        /// 请求数据，根据会话ID发送，
        /// 一般用于并发处理场合，根据ID来确认具体的发送会话，
        /// 用于服务监听应答场合
        /// </summary>
        /// <param name="sessionID">会话ID</param>
        /// <param name="request">请求发送的数据</param>
        public virtual void Request(Guid sessionID, TRequest request)
        {
            throw new Exception(string.Format("{0}不支持Request的调用", this.GetType().FullName));
        }
        /// <summary>
        /// 异步请求数据，在其他线程上
        /// </summary>
        /// <param name="data"></param>
        public virtual void ASyncRequest(TRequest data)
        {
            throw new Exception(string.Format("{0}不支持ASyncRequest的调用", this.GetType().FullName));
        }
        /// <summary>
        /// 请求等待应答数据
        /// </summary>
        /// <param name="data">请求数据</param>
        /// <param name="timeOut">请求超时时间，单位是毫秒</param>
        /// <returns>
        /// 返回响应数据
        /// </returns>
        public virtual TResponse RequestWait(TRequest data, int timeOut = 500)
        {
            throw new Exception(string.Format("{0}不支持RequestWait的调用", this.GetType().FullName));
        }
        /// <summary>
        /// 异步请求等待应答数据,一般用于批量请求
        /// 在回调中执行处理
        /// </summary>
        /// <param name="data">异步请求数据</param>
        public virtual void AsyncRequestWait(AsyncRequestWaitHandler<TRequest, TResponse> asyncRequestWait, TRequest requestData)
        {
            throw new Exception(string.Format("{0}不支持AsyncRequestWait的调用", this.GetType().FullName));
        }
        #endregion
        /// <summary>
        /// 压入数据
        /// </summary>
        /// <param name="obj"></param>
        protected virtual void Post(object obj)
        {
            if (responseMessageFIFO != null && responseMessageFIFO.IsOpened == true)
            {
                responseMessageFIFO.Post(obj);
            }
            else
            {
                if (obj is Exception)
                {
                    if (OnException != null)
                    {
                        OnException(this, (Exception)obj);
                    }
                }
                else if (obj is string)
                {
                    if (OnInfo != null)
                    {
                        OnInfo(this, (string)obj);
                    }
                }
            }
        }
        /// <summary>
        /// 并发式处理
        /// </summary>
        protected virtual void ParallelPost(object obj)
        {
            System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(responseMessageFIFO_Exceute), obj);
        }
        /// <summary>
        /// 回调处理数据
        /// </summary>
        /// <param name="obj"></param>
        void responseMessageFIFO_Exceute(object obj)
        {
            if (obj is Exception)
            {
                if (OnException != null)
                {
                    OnException(this, (Exception)obj);
                }
            }
            else if (obj is TResponse)
            {
                if (OnResponseBuffer != null)
                {
                    OnResponseBuffer(this, (TResponse)obj);
                }
            }
            else if (obj is string)
            {
                if (OnInfo != null)
                {
                    OnInfo(this, (string)obj);
                }
            }
        }
        /// <summary>
        /// 响应消息队列启动
        /// </summary>
        protected virtual void OpenRespnoseMessageFIFO()
        {
            if (responseMessageFIFO == null)
            {
                responseMessageFIFO = new IoCompletionMessageFIFO();
                responseMessageFIFO.Exceute += responseMessageFIFO_Exceute;
            }
            if (responseMessageFIFO != null && responseMessageFIFO.IsOpened == false)
            {
                responseMessageFIFO.Start();
            }
        }
        /// <summary>
        /// 响应消息队列关闭
        /// </summary>
        protected virtual void CloseResponseMessageFIFO()
        {
            if (responseMessageFIFO != null && responseMessageFIFO.IsOpened == true)
            {
                responseMessageFIFO.Stop();
            }
        }
        /// <summary>
        /// 启动前触发
        /// </summary>
        /// <param name="status"></param>
        protected virtual void RaiseOpening(bool status)
        {
            if (OnOpening != null)
            {
                OnOpening(this, true);
            }
        }
        /// <summary>
        /// 启动后触发
        /// </summary>
        /// <param name="status"></param>
        protected virtual void RaiseOpened(bool status)
        {
            if (OnOpened != null)
            {
                OnOpened(this, true);
            }
        }
        /// <summary>
        /// 关闭前触发
        /// </summary>
        /// <param name="status"></param>
        protected virtual void RaiseClosing(bool status)
        {
            if (OnClosing != null)
            {
                OnClosing(this, true);
            }
        }
        /// <summary>
        /// 关闭后触发
        /// </summary>
        /// <param name="status"></param>
        protected virtual void RaiseClosed(bool status)
        {
            if (OnClosed != null)
            {
                OnClosed(this, true);
            }
        }
        /// <summary>
        /// 连接会话建立后触发
        /// </summary>
        /// <param name="session">连接会话</param>
        /// <returns></returns>
        protected virtual ConnectSession<TRequest,TResponse> RaiseConnectSession(ConnectSession<TRequest,TResponse> session)
        {
            if (OnSessionAdded != null)
            {
                OnSessionAdded(session);
            }
            return session;
        }
        /// <summary>
        /// 应答数据事件
        /// </summary>
        public event ResponseHandler<TResponse> OnResponseBuffer;
        /// <summary>
        /// 应答异常
        /// </summary>
        public event ExceptionHandler<Exception> OnException;
        /// <summary>
        /// 应答普通消息
        /// </summary>
        public event ExceptionHandler<string> OnInfo;
        /// <summary>
        /// 打开前触发
        /// </summary>
        public event ResponseHandler<bool> OnOpening;
        /// <summary>
        /// 打开后触发
        /// </summary>
        public event ResponseHandler<bool> OnOpened;
        /// <summary>
        /// 关闭前触发
        /// </summary>
        public event ResponseHandler<bool> OnClosing;
        /// <summary>
        /// 关闭后触发
        /// </summary>
        public event ResponseHandler<bool> OnClosed;
        /// <summary>
        /// 会话构建后触发
        /// </summary>
        public event SessionHandler<TRequest,TResponse> OnSessionAdded;


        
    }


具体的通信实现类：



    /// <summary>
    /// TCP主动监听模式，读取应答交互方式
    /// 此模式应答数据统一到一个线程上处理,排队进行数据应答
    /// </summary>
    /// <typeparam name="TOutputMessageFilter">传入的应答消息过滤器类型</typeparam>
    /// <typeparam name="TResponse">传入的应答数据类型</typeparam>
    internal class TCPHostSingleServerCommunication<TInputMessageFilter, TOutputMessageFilter, TRequest, TResponse> 
        : BaseCommunication<TRequest, TResponse>
        where TInputMessageFilter : BaseInPutMessageFilter<TRequest>
        where TOutputMessageFilter : BaseOutPutMessageFilter<TRequest,TResponse>
        where TRequest:IRequestData
        where TResponse : IResponseData
    {
        /// <summary>
        /// TCP连接地址
        /// </summary>
        IPEndPoint end;
        /// <summary>
        /// 网络连接的IP地址和端口号
        /// </summary>
        string endPort;
        /// <summary>
        /// 已建立的会话
        /// </summary>
        private List<ConnectSession<TRequest, TResponse>> connectSessionList = new List<ConnectSession<TRequest, TResponse>>();
        /// <summary>
        /// 等待中的连接
        /// </summary>
        private List<IAsyncResult> waitAcceptSocketList = new List<IAsyncResult>();
        /// <summary>
        /// 连接处理锁
        /// </summary>
        private object acceptLock = new object();
        /// <summary>
        /// 用于Socket监听的托管队列
        /// </summary>
        private IoCompletionMessageFIFO acceptFIFO = new IoCompletionMessageFIFO();
        /// <summary>
        /// 监听信号量
        /// </summary>
        private ManualResetEvent acceptWaitResetEvent = new ManualResetEvent(false);
        /// <summary>
        /// 通信端口初始化参数
        /// </summary>
        protected TCPHostServerParamertercs communicationParamerters;
        /// <summary>
        /// 连接模式构造
        /// </summary>
        /// <param name="ip">监听的IP地址</param>
        /// <param name="port">端口号</param>
        public TCPHostSingleServerCommunication(string ip, int port)
        {
            this.end = new IPEndPoint(IPAddress.Parse(ip), port);
            this.endPort = string.Format("{0}:{1}", ip, port);
            acceptFIFO.Exceute += acceptFIFO_Exceute;
        }
        /// <summary>
        /// 监听托管队列处理回调
        /// </summary>
        /// <param name="obj"></param>
        void acceptFIFO_Exceute(object obj)
        {
            if (obj is SocketCommand)
            {
                SocketCommand socketCommand = (SocketCommand)obj;
                if (socketCommand == SocketCommand.Start)
                {
                    this.StartConnectNetWork();
                }
            }
        }
        /// <summary>
        /// 打开
        /// 如果打开失败，会自动尝试关闭掉
        /// </summary>
        public override void Open()
        {
            if (communicationParamerters == null)
            {
                throw new Exception("设备端口参数未初始化");
            }
            try
            {
                RaiseOpening(true);
                acceptFIFO.Start();
                System.Threading.Thread.Sleep(200);
                if (acceptFIFO != null && acceptFIFO.IsOpened == true)
                {
                    acceptFIFO.Post(SocketCommand.Start);
                }
                this.OpenRespnoseMessageFIFO();
            }
            catch (Exception ex)
            {
                Exception portExcp = new Exception(string.Format("网口【{0}】打开失败，失败原因：{1}", endPort, ex.Message));
                this.Post(portExcp);
                throw portExcp;
            }
        }
        /// <summary>
        /// 通信端口初始化
        /// </summary>
        /// <param name="communicationParamerters"></param>
        public override void InitCommunication(Trace.CMS.Communication.BaseCommunicationParamerters communicationParamerters)
        {
            this.communicationParamerters = (TCPHostServerParamertercs)communicationParamerters;
        }
        /// <summary>
        /// 开始网络监听
        /// </summary>
        private void StartConnectNetWork()
        {
            try
            {
                acceptWaitResetEvent.Reset();
                Socket socket = new Socket(end.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
                socket.Bind(end);
                socket.Listen(0xFFFF);
                AsyncCallback acceptCallback = new AsyncCallback(CallbackAccept);
                lock (acceptLock)
                {
                    IAsyncResult beginAr = socket.BeginAccept(acceptCallback, socket);
                    waitAcceptSocketList.Add(beginAr);
                }
                RaiseOpened(true);
                acceptWaitResetEvent.WaitOne();
                this.StopConnectNetWork();
                System.Threading.Thread.Sleep(200);
                if (socket != null)
                {
                    socket.Close();
                }
                RaiseClosed(true);
            }
            catch (Exception ex)
            {
                this.Post(new Exception(string.Format("连接托管异常,异常原因：{0}", ex.Message)));
            }
        }
        /// <summary>
        /// 监听到一个异步连接
        /// 此处用于处理已监听到的连接，并发起新的监听连接,剔除掉死链接
        /// </summary>
        /// <param name="ar"></param>
        private void CallbackAccept(IAsyncResult ar)
        {
            if (ar.IsCompleted == false)
            {
                return;
            }
            if (IsOpen == true)
            {
                try
                {
                    byte[] inOptionValues = GetOptionValues();
                    Socket tempSocket = (Socket)ar.AsyncState;
                    Socket endAcceptSocket = tempSocket.EndAccept(ar);
                    ConnectSession<TRequest, TResponse> connectSession = ConnectSession<TRequest, TResponse>.Create<TInputMessageFilter, TOutputMessageFilter>();
                    connectSession.ReciveSocket = endAcceptSocket;
                    connectSession.ReciveSocket.IOControl(IOControlCode.KeepAliveValues, inOptionValues, null);//IO控制防止死连接
                    connectSession = RaiseConnectSession(connectSession);
                    connectSession.ReciveSocket.BeginReceive(connectSession.ReciveBuffer, 0, connectSession.ReciveBuffer.Length, SocketFlags.None, new AsyncCallback(OnDataRead), connectSession);
                    lock (acceptLock)
                    {
                        connectSessionList.Add(connectSession);
                        IAsyncResult tempAr = waitAcceptSocketList.Find(delegate(IAsyncResult delAr) { return delAr.AsyncWaitHandle.SafeWaitHandle.Equals(ar.AsyncWaitHandle.SafeWaitHandle); });
                        if (tempAr != null)
                        {
                            waitAcceptSocketList.Remove(tempAr);
                        }
                    }
                    IPAddress ip = ((System.Net.IPEndPoint)endAcceptSocket.RemoteEndPoint).Address;
                    int remotePort = ((System.Net.IPEndPoint)endAcceptSocket.RemoteEndPoint).Port;
                    this.Post(string.Format("远程客户端：【{0}:{1}】连接成功", ip.ToString(), remotePort));
                }
                catch (Exception ex)
                {
                    this.Post(new Exception(string.Format("新的全连接添加失败，失败原因：{0}", ex.Message)));
                }
                try
                {
                    AsyncCallback acceptCallback = new AsyncCallback(CallbackAccept);
                    lock (acceptLock)
                    {
                        Socket tempSocket = (Socket)ar.AsyncState;
                        IAsyncResult beginAr = tempSocket.BeginAccept(acceptCallback, tempSocket);
                        waitAcceptSocketList.Add(beginAr);
                    }
                }
                catch (Exception ex)
                {
                    this.Post(new Exception(string.Format("新的半连接添加失败，失败原因：{0}", ex.Message)));
                }
            }
            else
            {
                try
                {
                    Socket tempSocket = (Socket)ar.AsyncState;
                    if (tempSocket == null)
                    {
                        return;
                    }
                    Socket endAcceptSocket = tempSocket.EndAccept(ar);
                    IPAddress ip = null;
                    int remotePort = 0;
                    if (endAcceptSocket != null)
                    {
                        ip = ((System.Net.IPEndPoint)endAcceptSocket.RemoteEndPoint).Address;
                        remotePort = ((System.Net.IPEndPoint)endAcceptSocket.RemoteEndPoint).Port;
                    }
                    if (endAcceptSocket != null)
                    {
                        endAcceptSocket.Close();
                    }
                    if (ip != null)
                    {
                        this.Post((string.Format("尝试关闭系统时，客户端发起的新的连接【{0}:{1}】强制关闭成功", ip.ToString(), remotePort)));
                    }
                }
                catch (Exception ex)
                {
                    this.Post(string.Format("关闭系统后发起的监听连接关闭失败，失败原因：{0}", ex.Message));
                }
            }
        }
        #region 请求写入数据
        /// <summary>
        /// 请求数据，根据会话ID发送，
        /// 一般用于并发处理场合，根据ID来确认具体的发送会话，
        /// 用于服务监听应答场合
        /// </summary>
        /// <param name="sessionID">会话ID</param>
        /// <param name="data">数据</param>
        public override void Request(Guid sessionID, TRequest data)
        {
            ConnectSession<TRequest, TResponse> tempConnectSession;
            lock (acceptLock)
            {
                tempConnectSession = connectSessionList.Find(delegate(ConnectSession<TRequest, TResponse> obj) { return obj.SessionID == sessionID; });
            }
            if (tempConnectSession != null)
            {
                this.SendDataEx(tempConnectSession, data);
            }
        }
        /// <summary>
        /// 发送数据
        /// </summary>
        private void SendDataEx(ConnectSession<TRequest, TResponse> tempConnection, TRequest data)
        {
            IInPutMessageFilter<TRequest> inputMessageFilter = tempConnection.InputMessageFilter;
            byte[] sendBuffer = inputMessageFilter.Process(data);
            tempConnection.ReciveSocket.BeginSend(sendBuffer, 0, sendBuffer.Length, SocketFlags.None, new AsyncCallback(OnDataSend), tempConnection);
        }
        /// <summary>
        /// 异步发送数据
        /// </summary>
        /// <param name="ar"></param>
        protected virtual void OnDataSend(IAsyncResult ar)
        {
            ConnectSession<TRequest, TResponse> tempSession = ar.AsyncState as ConnectSession<TRequest, TResponse>;
            SocketError socketError;
            Int32 bufferSize = tempSession.ReciveSocket.EndSend(ar, out socketError);
            if (socketError != SocketError.Success)
            {
                this.Post(new Exception(SocketErrorInfo.GetErrorMessage(socketError)));
            }
        }
        #endregion
        #region 应答处理
        /// <summary>
        /// 接收数据
        /// </summary>
        /// <param name="ar"></param>
        protected virtual void OnDataRead(IAsyncResult ar)
        {
            if (IsOpen == false)//关闭连接时不再处理各种可能的数据
            {
                return;
            }
            try
            {
                ConnectSession<TRequest, TResponse> tempSession = ar.AsyncState as ConnectSession<TRequest, TResponse>;
                SocketError socketError;
                Int32 bufferSize = tempSession.ReciveSocket.EndReceive(ar, out socketError);
                if (socketError != SocketError.Success)
                {
                    ErrorForceClose(tempSession, socketError);
                }
                if (bufferSize == 0)
                {
                    if (IsOpen == true)
                    {
                        FoceClose(tempSession);
                    }
                    return;
                }
                tempSession.MemoryStream.Write(tempSession.ReciveBuffer, 0, bufferSize);
                if (tempSession.ReciveSocket.Available <= 0)
                {
                    byte[] buffer = tempSession.MemoryStream.ToArray();
                    tempSession.MemoryStream.Position = 0;
                    tempSession.MemoryStream.Close();
                    tempSession.MemoryStream = new MemoryStream();
                    TResponse resopnseData = tempSession.OutputMessageFilter.Filter(buffer);
                    if (resopnseData != null)
                    {
                        this.ParallelPost(resopnseData);
                    }
                }
                tempSession.ReciveSocket.BeginReceive(tempSession.ReciveBuffer, 0, tempSession.ReciveBuffer.Length, SocketFlags.None, new AsyncCallback(OnDataRead), tempSession);
            }
            catch (Exception ex)
            {
                if (ex is TCPConnectException)
                {
                    this.Post(string.Format("网口连接发生了一个故障，等待客户端重新建立连接，故障原因：{0}", ex.Message));
                }
                else
                {
                    this.Post(new TCPConnectException(ex.Message));
                }
            }
        }


        #endregion
        /// <summary>
        /// 关闭网路连接
        /// </summary>
        public override void Close()
        {
            try
            {
                RaiseClosing(true);
                this.CloseResponseMessageFIFO();
                acceptWaitResetEvent.Set();
                acceptFIFO.Stop();
            }
            catch (Exception ex)
            {
                Exception portException = new Exception(string.Format("网口【{0}】关闭失败，失败原因：{1}", endPort, ex.Message));
                this.Post(portException);
                throw portException;
            }
        }
        /// <summary>
        /// 错误强制关闭连接
        /// </summary>
        /// <param name="tempSession"></param>
        /// <param name="socketError"></param>
        private void ErrorForceClose(ConnectSession<TRequest, TResponse> tempSession, SocketError socketError)
        {
            IPAddress ip = ((System.Net.IPEndPoint)tempSession.ReciveSocket.RemoteEndPoint).Address;
            int remotePort = ((System.Net.IPEndPoint)tempSession.ReciveSocket.RemoteEndPoint).Port;
            try
            {
                if (tempSession.ReciveSocket != null && tempSession.ReciveSocket.Connected == true)
                {
                    SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                    e.AcceptSocket = tempSession.ReciveSocket;
                    tempSession.ReciveSocket.DisconnectAsync(e);//异常连接直接强制关闭
                }
                lock (acceptLock)
                {
                    if (connectSessionList.Contains(tempSession))
                    {
                        connectSessionList.Remove(tempSession);
                    }
                }
            }
            catch
            {


            }
            finally
            {
                string errorMessage = SocketErrorInfo.GetErrorMessage(socketError);
                if (!string.IsNullOrEmpty(errorMessage))
                {
                    throw new TCPConnectException(string.Format("端口【{0}】监听的客户端【{1}:{2}】接收数据异常，异常原因：{3}", endPort, ip.ToString(), remotePort, errorMessage));
                }
                else
                {
                    throw new TCPConnectException(string.Format("端口【{0}】监听的客户端【{1}:{2}】接收数据异常", endPort, ip.ToString(), remotePort));
                }
            }
        }
        /// <summary>
        /// 强制关闭连接
        /// </summary>
        /// <param name="tempSession"></param>
        protected virtual void FoceClose(ConnectSession<TRequest, TResponse> tempSession)
        {
            IPAddress ip = ((System.Net.IPEndPoint)tempSession.ReciveSocket.RemoteEndPoint).Address;
            int remotePort = ((System.Net.IPEndPoint)tempSession.ReciveSocket.RemoteEndPoint).Port;
            try
            {
                if (tempSession.ReciveSocket != null && tempSession.ReciveSocket.Connected == true)
                {
                    SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                    e.AcceptSocket = tempSession.ReciveSocket;
                    tempSession.ReciveSocket.DisconnectAsync(e);//异常连接直接强制关闭
                }
                lock (acceptLock)
                {
                    if (connectSessionList.Contains(tempSession))
                    {
                        connectSessionList.Remove(tempSession);
                    }
                }
            }
            catch
            {


            }
            finally
            {
                this.Post(string.Format("端口【{0}】监听的客户端【{1}:{2}】主动关闭连接,等待客户端建立新的连接", endPort, ip.ToString(), remotePort));
            }
        }
        /// <summary>
        /// 停止网络连接,逐步释放资源
        /// </summary>
        private void StopConnectNetWork()
        {
            StringBuilder connectInfo = new StringBuilder();
            StringBuilder connectExp = new StringBuilder();
            lock (acceptLock)
            {
                if (waitAcceptSocketList.Count > 0)
                {
                    for (int i = 0; i < waitAcceptSocketList.Count; i++)
                    {
                        try
                        {
                            IAsyncResult waitAr = waitAcceptSocketList[i];
                            waitAr.AsyncWaitHandle.SafeWaitHandle.Close();
                            connectInfo.AppendLine("半连接关闭成功");
                        }
                        catch (Exception ex)
                        {
                            connectExp.AppendLine(string.Format("WaitAr释放异常，异常原因：{0}", ex.Message));
                        }
                    }
                }
                if (connectSessionList.Count > 0)
                {
                    for (int i = 0; i < connectSessionList.Count; i++)
                    {
                        try
                        {
                            Socket tempSocket = connectSessionList[i].ReciveSocket;
                            IPAddress ip = null;
                            int remotePort = 0;
                            if (tempSocket != null)
                            {
                                ip = ((System.Net.IPEndPoint)tempSocket.RemoteEndPoint).Address;
                                remotePort = ((System.Net.IPEndPoint)tempSocket.RemoteEndPoint).Port;
                            }
                            if (tempSocket != null)
                            {
                                tempSocket.Close();
                            }
                            if (ip != null)
                            {
                                connectInfo.AppendLine(string.Format("全连接对应的远程客户端【{0}:{1}】关闭成功", ip.ToString(), remotePort));
                            }
                        }
                        catch (Exception ex)
                        {
                            connectExp.AppendLine(string.Format("AcceptSocket释放异常，异常原因：{0}", ex.Message));
                        }
                    }
                }
                if (connectInfo.Length > 0)
                {
                    this.Post(connectInfo.ToString());
                }
                if (connectExp.Length > 0)
                {
                    this.Post(new Exception(connectExp.ToString()));
                }
            }
        }
        /// <summary>
        /// 获取心跳包参数
        /// </summary>
        /// <returns></returns>
        private byte[] GetOptionValues()
        {
            uint dummy = 0;
            byte[] inOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
            BitConverter.GetBytes((uint)1).CopyTo(inOptionValues, 0);
            BitConverter.GetBytes((uint)communicationParamerters.HeartRateTimeOut * 100).CopyTo(inOptionValues, Marshal.SizeOf(dummy));
            BitConverter.GetBytes((uint)communicationParamerters.HeartRateTimeOut * 100).CopyTo(inOptionValues, Marshal.SizeOf(dummy) * 2);
            return inOptionValues;
        }
    }


应答消息拦截器接口：

 

 /// <summary>
    /// 消息过滤接口
    /// 消息过滤出来后，转化成对应的应答数据
    /// </summary>
    public interface IOutPutMessageFilter<TRequest,TResponse>
        where TRequest : IRequestData
        where TResponse : IResponseData
    {
        /// <summary>
        /// 会话ID
        /// </summary>
        Guid SessionID { get; }
        /// <summary>
        /// 应答数据过滤
        /// </summary>
        /// <returns>
        /// 返回对应类型的应答数据
        /// </returns>
        TResponse Filter(byte[] buffer);
        /// <summary>
        /// 请求命令队列
        /// 应答式的请求处理时，可以用于获取对应的请求命令
        /// </summary>
        void RequestCommandQueue(RequestWaitCommand<TRequest,TResponse> command);
        /// <summary>
        /// 等待应答数据
        /// </summary>
        /// <returns></returns>
        TResponse WaitResponseData(RequestWaitCommand<TRequest,TResponse> command);
    }

 输入消息构造器接口：

/// <summary>
    /// 输入消息构建器接口
    /// </summary>
    public interface IInPutMessageFilter<TRequestData> 
        where TRequestData:IRequestData
    {
        /// <summary>
        /// 会话ID
        /// </summary>
        Guid SessionID { get; }
        /// <summary>
        /// 处理请求数据到字节流
        /// </summary>
        /// <param name="requestData">请求数据</param>
        /// <returns>
        /// 返回请求数据对应的字节流
        /// </returns>
        byte[] Process(TRequestData requestData);
    }

 

请求数据接口:

 /// <summary>
    /// 请求数据
    /// </summary>
    public interface IRequestData
    {
        /// <summary>
        /// 请求数据描述
        /// </summary>
        string Describe { get; }
        /// <summary>
        /// 是否是异步等待应答数据
        /// </summary>
        bool IsAsyncWaitData { get; }
        /// <summary>
        /// 异步请求等待超时
        /// </summary>
        int AsyncRequestWaitTimeOut { get; }
        /// <summary>
        /// 异步请求执行失败，是否再次执行
        /// </summary>
        bool AsyncIsExcuteAgain { get; set; }
    }


 应答数据接口：

 /// <summary>
    /// 响应数据接口
    /// </summary>
    public interface IResponseData
    {
        /// <summary>
        /// 响应会话ID
        /// </summary>
        Guid SessionID { get; }
       /// <summary>
       /// 应答异常
       /// </summary>
        Exception ResponseException { get; set; }
    }

会话构造类： 

/// <summary>
    /// 连接会话
    /// </summary>
    /// <typeparam name="TRequest">请求数据</typeparam>
    /// <typeparam name="TResponse">应答数据</typeparam>
    public class ConnectSession<TRequest,TResponse>
        where TRequest:IRequestData
        where TResponse : IResponseData
    {
        private ConnectSession()
        {

        }
        /// <summary>
        /// 构建会话
        /// </summary>
        /// <typeparam name="TInputMessageFilter">请求消息过滤器</typeparam>
        /// <typeparam name="TOutputMessageFilter">应答消息过滤器</typeparam>
        /// <returns></returns>
        public static ConnectSession<TRequest, TResponse> Create<TInputMessageFilter, TOutputMessageFilter>()
            where TInputMessageFilter : class,IInPutMessageFilter<TRequest>
            where TOutputMessageFilter : class,IOutPutMessageFilter<TRequest,TResponse>
        {
            ConnectSession<TRequest, TResponse> connection = new ConnectSession<TRequest, TResponse>();
            connection.sessionID = Guid.NewGuid();
            connection.createTime = DateTime.Now;
            connection.outputMessageFilter = Activator.CreateInstance<TOutputMessageFilter>();
            connection.inputMessageFilter = Activator.CreateInstance<TInputMessageFilter>();
            return connection;
        }
        private Guid sessionID;
        /// <summary>
        /// 会话ID
        /// </summary>
        public Guid SessionID
        {
            get
            {
                return sessionID;
            }
        }
        private DateTime createTime;
        /// <summary>
        /// 创建时间
        /// </summary>
        public DateTime CreateTime
        {
            get
            {
                return createTime;
            }
        }
        private IOutPutMessageFilter<TRequest,TResponse> outputMessageFilter;
        /// <summary>
        /// 输出消息过滤器
        /// </summary>
        public IOutPutMessageFilter<TRequest,TResponse> OutputMessageFilter
        {
            get
            {
                return outputMessageFilter;
            }
        }
        private IInPutMessageFilter<TRequest> inputMessageFilter;
        /// <summary>
        /// 输入消息过滤器
        /// </summary>
        public IInPutMessageFilter<TRequest> InputMessageFilter
        {
            get
            {
                return inputMessageFilter;
            }
        }


gongbenwen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2、TCP通用服务器（TCP服务端，接收客户端内容，然后输出）
weixin_44772874的博客
08-20 2254
TCP通用服务器（TCP服务端，接收客户端内容，然后输出） ServerSocket类 方法签名 方法说明 ServerSocket(int port) 创建绑定到指定端口的服务器套接字 ServerSocket(int port, int backlog) 创建服务器套接字并将其绑定到指定的本地端口号，并指定了积压。 Socket accept() 侦听要连接到此套接字并接受它 bind(SocketAddress endpoint) 将ServerSocket绑定到特定地址（
自己写一个tcp 通用服务器
03-14
NULL 博文链接：https://erlangdisplay.iteye.com/blog/315444
TCP协议服务器/客户端框架
01-06
包含完整的C#源程序、示例、可直接引用的dll以及性能测试项目。可直接调用用于网络开发。
TCP和MODBUS-TCP通讯调试软件V1.2_Wince_Windows_通用版
03-18
TCP和MODBUS-TCP通讯调试软件V1.2_Wince_Windows_通用版调试测试工具，能方便编写针对Modbus-tcp连接的服务器和客户端程序
一个Windows和Linux下通用的tcp服务端框架
无极之道的专栏
05-29 559
/* * ===================================================================================== * * Filename: main.cpp * * Description: socket programe test for FCW_STL * * Version: 1.0
DEARTCP1.2-通用TCP服务器组件，用于创建物联网开发
ggbb190的专栏
03-22 1144
通用tcp异步开发组件
易语言-Hp-Socket For E 5.3.2 高性能TCP/UDP通信组件 源码+模块+例程
06-29
HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、客户端组件和Agent组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程...
HP-Socket通信框架-其他
06-12
HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、客户端组件和Agent组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程...
HP-Socket 网络通信框架开发指南
07-17
HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、 客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通 信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等...
Windows下基于socket多线程并发通信的实现
04-07
本文介绍了在Windows 操作系统下基于TCP/IP 协议Socket 套接口的通信机制以及多线程编程知识与技巧，并给出多线程方式实现多用户与服务端(C/S)并发通信模型的详细算法，最后展现了用C++编写的多用户与服务器通信的...
易语言-Hp-Socket For E 5.4.2 高性能TCP/UDP通信组件 源码+模块+例程
06-29
HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、客户端组件和Agent组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程...
TCP并发服务器模型（一）
图像、视频、算法、Linux
03-14 3126
本篇叙述的TCP并发服务器模型如下图所示： 服务器创建并绑定套接字后fork出几个子进程，子进程中分别进行accept（该函数为阻塞函数）、recv、处理数据然后再次acept，这样循环下去。所有客户端发来的信息都是直接由子进程处理。 例程 代码如下，在处理客户端请求之前，服务器先fork了3个子进程，然后将客户端的请求直接交由子进程处理。 该例程中，服务器fork子进程后，子进程监听并接收
轻量级短请求快速处理线程池
gongbenwen的专栏
09-07 509
在实时控制领域的调度中，上位机与设备间的交互依赖各种通信，
【Socket】：实现一个简单通用的Tcp和Udp服务器及客户端
HanSion.Z
01-12 1527
前言：本篇博客利用Socket API实现一个简单通用的Tcp及Udp服务器及客户端。并且将Tcp版本的服务器改为多进程版本和多线程版本以及引入线程池。 网络编程套接字：https://blog.csdn.net/hansionz/article/details/85226345 1. 实现一个通用简单Udp服务器/客户端 封装udp的socket接口 //udp_socket.hpp #pr...
socket通信之一：TCP/IP模型与socket
09-02 8092
这段时间看了一些网络相关的东西，这里做一个总结吧。参考了很多文章的内容，因为我本身是对着书并且参考网络资源在学习的，在最后会一一列出文章的地址。 这篇文章主要介绍TCP/IP的一些基本知识，后面几篇继续深入一点探究。 本篇主要包括下面这些知识： TCP/IP是什么socket介绍socket通信流程socket中TCP三次握手建立连接socket中TCP的四次挥手释放连接
socket TCP：在阿里云ESC上搭建自己的TCP服务端程序
热门推荐
Forever1715的博客
05-29 1万+
1 背景介绍 在日常单片机/安卓开发过程当中，经常有一些小项目会用到C/S架构。比如，想要实现两个单片机想要实现远程通信，那么就不得不自己搭建一个服务器来实现转发（或许有其他方法）。这样两个单片机就可以通过一些通信模块（WIFI，GPRS等）来实现相互通信了。当然，我们可以在调试的过程中，完全可以利用自己的电脑搭建一个局域网内的通信。但是在实际中我们可能更加需要非局域网的通信，因此自己搭建一个阿里...
网络编程之：TCP服务器的简单实现
m0_67403013的博客
04-29 1618
说到TCP服务器，就不得不提socket编程，我们知道，在TCP/IP协议中,“IP地址+TCP或UDP端口号”唯一标识络通讯中的唯一一个进程,“IP地址+端口号”就称为socket。 在TCP协议中,建立连接的两个进程各自有一个socket来标识,那么这两个socket组成 的socket pair就唯一标识一个连接。socket本身有“插座”的意思,因此来描述网络连接的一 对的关 系。 TCP/IP协议最早在BSD UNIX上实现,为TCP/IP协议设计的应用层编程接口称为socket API。 TCP
基于C++的纯面向对象的通用高性能大并发TCP-SERVER/CLIENT开发框架实践系列之基础篇
一见
12-21 9936
基于C++的纯面向对象的通用高性能大并发TCP-SERVER/CLIENT开发框架实践系列之基础篇yijian 2008-12-21 [email protected]. 前言本篇主要介绍Servant和Client都会使用到的公共基础，主要包括两大部分：一是对线程相关的封装；另是对Socket相关的封装。这些基础类间的关系比较简单，但是和Server/Client框架息息
netty实现tcp通信服务端代码
最新发布
03-30
下面是 Netty 实现 TCP 通信服务端的代码示例： ``` import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.Channel; import io.netty.channel.ChannelOption; import io.netty.channel....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值