介绍开源的.net通信框架NetworkComms框架 源码分析（十七 ） ConnectionSendClose

原文网址： http://www.cnblogs.com/csdev

Networkcomms 是一款C# 语言编写的TCP/UDP通信框架  作者是英国人  以前是收费的 目前作者已经开源  许可是:Apache License v2

开源地址是:https://github.com/MarcFletcher/NetworkComms.Net

 public abstract partial class Connection : IDisposable
    {
        /// <summary>
        /// Lockers for maintaining thread safe operation
        /// 同步锁
        /// </summary>
        protected object sendLocker = new object();

        /// <summary>
        /// A NetworkComms.Net math object for tracking send times. Used to prevent send deadlocks.
        /// Initialised at 1000 milliseconds per KB write speed, corresponding with 1KB / second.
        /// 一个数学类 用来跟踪发送事件 以阻止死锁显现的发生
        /// 初始化为  1KB每秒的发送速度
        /// </summary>
        protected CommsMath SendTimesMSPerKBCache;

        /// <summary>
        /// A counter which is incremented during every a send. The current value is included in the header of all sent packets.
        /// 数据包的顺序号 一个递增计数器，在每一个发送数据包的报头中会包含。
        /// </summary>
        protected long packetSequenceCounter;

        /// <summary>
        /// Maintains a list of sent packets for the purpose of confirmation and possible resends.
        /// 同步锁
        /// </summary>
        object sentPacketsLocker = new object();
        //已发送过的数据包存放在此处 以备对方没有收到需要重发   超过一定的时间会删除 只保留一定时间内的数据包
        Dictionary<string, SentPacket> sentPackets = new Dictionary<string, SentPacket>();

        /// <summary>
        /// Send bytes on an unmanaged connection
        /// 在“未托管”的连接上发送字节
        /// </summary>
        /// <param name="bytesToSend">The bytes to send</param>
        public void SendUnmanagedBytes(byte[] bytesToSend)
        {
            if (ConnectionInfo.ApplicationLayerProtocol != ApplicationLayerProtocolStatus.Disabled)
                throw new CommunicationException("Attempted to send unmanaged bytes on a managed connection. This method should only be used on connections which have the ApplicationLayerProtocol disabled.");

            SendObject<byte[]>(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Unmanaged), bytesToSend);
        }

        /// <summary>
        /// Send an object using the connection default <see cref="SendReceiveOptions"/>
        /// 发送数据使用默认的收发参数
        /// </summary>
        /// <param name="sendingPacketType">消息类型  The sending packet type</param>
        /// <param name="objectToSend">发送的对象  The object to send</param>
        public void SendObject<sendObjectType>(string sendingPacketType, sendObjectType objectToSend)
        {
            SendObject(sendingPacketType, objectToSend, ConnectionDefaultSendReceiveOptions);
        }

        /// <summary>
        /// Send an object using the connection default <see cref="SendReceiveOptions"/>
        /// 发送数据使用默认的收发参数
        /// </summary>
        /// <param name="sendingPacketType">消息类型  The sending packet type</param>
        /// <param name="objectToSend">发送的对象 The object to send</param>
        /// <param name="packetSequenceNumber">发送的数据包的顺序号 The sequence number of the packet sent</param>
        public void SendObject<sendObjectType>(string sendingPacketType, sendObjectType objectToSend, out long packetSequenceNumber)
        {
            SendObject(sendingPacketType, objectToSend, ConnectionDefaultSendReceiveOptions, out packetSequenceNumber);
        }

        /// <summary>
        /// Send an object using the provided SendReceiveOptions
        /// 用参数中指定的收发参数  发送数据包
        /// </summary>
        /// <param name="sendingPacketType">消息类型  The packet type to use for send</param>
        /// <param name="objectToSend">发送的对象  The object to send</param>
        /// <param name="options">收发参数  Send specific <see cref="SendReceiveOptions"/></param>
        public void SendObject<sendObjectType>(string sendingPacketType, sendObjectType objectToSend, SendReceiveOptions options)
        {
            //Check to see if we already have a packet
            //检查要发送的数据本身是否为数据包
            Packet objectToSendAsPacket = objectToSend as Packet;
            if (objectToSendAsPacket == null)
            {
                using (Packet sendPacket = new Packet(sendingPacketType, objectToSend, options))
                    SendPacket<sendObjectType>(sendPacket);
            }
            else
            {
                if (objectToSendAsPacket.PacketHeader.PacketType != sendingPacketType)
                    throw new ArgumentException("Unable to send object of type Packet if the PacketHeader.PacketType and sendingPacketType do not match.");

                SendPacket<sendObjectType>(objectToSendAsPacket);
            }
        }

        /// <summary>
        /// Send an object using the provided SendReceiveOptions
        /// 用参数中指定的收发参数  发送数据包
        /// </summary>
        /// <param name="sendingPacketType">消息类型 The packet type to use for send</param>
        /// <param name="objectToSend">发送的对象 The object to send</param>
        /// <param name="options">收发参数  Send specific <see cref="SendReceiveOptions"/></param>
        /// <param name="packetSequenceNumber">顺序号  The sequence number of the packet sent</param>
        public void SendObject<sendObjectType>(string sendingPacketType, sendObjectType objectToSend, SendReceiveOptions options, out long packetSequenceNumber)
        {
            Packet objectToSendAsPacket = objectToSend as Packet;
            if (objectToSendAsPacket == null)
            {
                using (Packet sendPacket = new Packet(sendingPacketType, objectToSend, options))
                    SendPacket<sendObjectType>(sendPacket, out packetSequenceNumber);
            }
            else
            {
                if (objectToSendAsPacket.PacketHeader.PacketType != sendingPacketType)
                    throw new ArgumentException("Unable to send object of type Packet if the PacketHeader.PacketType and sendingPacketType do not match.");

                SendPacket<sendObjectType>(objectToSendAsPacket, out packetSequenceNumber);
            }
        }

        /// <summary>
        /// Send an empty packet using the provided packetType. Useful for signalling.
        /// 根据指定的消息类型 发送一个空数据包 发送信号时有用
        /// </summary>
        /// <param name="sendingPacketType">The sending packet type</param>
        public void SendObject(string sendingPacketType)
        {
            SendObject<object>(sendingPacketType, null);
        }

        /// <summary>
        /// Send an empty packet using the provided packetType. Useful for signalling.
        /// 根据指定的消息类型 发送一个空数据包 发送信号时有用
        /// </summary>
        /// <param name="sendingPacketType">消息类型 The sending packet type</param>
        /// <param name="packetSequenceNumber">顺序号  The sequence number of the packet sent</param>
        public void SendObject(string sendingPacketType, out long packetSequenceNumber)
        {
            SendObject<object>(sendingPacketType, null, ConnectionDefaultSendReceiveOptions, out packetSequenceNumber);
        }

        /// <summary>
        /// Send an object using the connection default <see cref="SendReceiveOptions"/> and wait for a returned object
        /// again using default <see cref="SendReceiveOptions"/>.
        /// 发送并接收数据 （同步方法）
        /// </summary>
        /// <typeparam name="sendObjectType">发送的类的类型 The sending object type, i.e. string, int[], etc</typeparam>
        /// <typeparam name="returnObjectType">返回的类的类型  The type of return object</typeparam>
        /// <param name="sendingPacketTypeStr">发送的消息类型The sending packet type</param>
        /// <param name="expectedReturnPacketTypeStr">预期返回的消息类型The packet type which will be used for the reply</param>
        /// <param name="returnPacketTimeOutMilliSeconds">消息返回的超时时间  A timeout in milliseconds after which if not reply is received
        /// will throw an ExpectedReturnTimeoutException.</param>
        /// <param name="sendObject">发送的对象  The object to send</param>
        /// <returns>返回的对象  The requested return object</returns>
        public returnObjectType SendReceiveObject<sendObjectType, returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, sendObjectType sendObject)
        {
            return SendReceiveObject<sendObjectType, returnObjectType>(sendingPacketTypeStr, expectedReturnPacketTypeStr, returnPacketTimeOutMilliSeconds, sendObject, null, null);
        }

        /// <summary>
        /// Send an object using the connection default <see cref="SendReceiveOptions"/> and wait for a returned object again
        /// using default <see cref="SendReceiveOptions"/>.
        /// 发送并接收数据 （同步方法）
        /// </summary>
        /// <typeparam name="sendObjectType">发送的类的类型 The sending object type, i.e. string, int[], etc</typeparam>
        /// <typeparam name="returnObjectType">返回的类的类型  The type of return object</typeparam>
        /// <param name="sendingPacketTypeStr">发送的消息类型  The sending packet type</param>
        /// <param name="expectedReturnPacketTypeStr">预期返回的消息类型  The packet type which will be used for the reply</param>
        /// <param name="returnPacketTimeOutMilliSeconds">消息返回的超时时间  A timeout in milliseconds after which if not reply is received will
        /// throw an ExpectedReturnTimeoutException.</param>
        /// <param name="sendObject">发送的对象  The object to send</param>
        /// <param name="sentPacketSequenceNumber">包的顺序号  The sequence number of the packet sent</param>
        /// <returns>返回的对象  The requested return object</returns>
        public returnObjectType SendReceiveObject<sendObjectType, returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, sendObjectType sendObject, out long sentPacketSequenceNumber)
        {
            return SendReceiveObject<sendObjectType, returnObjectType>(sendingPacketTypeStr, expectedReturnPacketTypeStr, returnPacketTimeOutMilliSeconds, sendObject, null, null, out sentPacketSequenceNumber);
        }

        /// <summary>
        /// Send an object using the provided <see cref="SendReceiveOptions"/> and wait for a returned object using provided
        /// 发送并接收数据 （同步方法）
        /// </summary>
        /// <typeparam name="sendObjectType">发送的类的类型 The sending object type, i.e. string, int[], etc</typeparam>
        /// <typeparam name="returnObjectType">返回的类的类型  The type of return object</typeparam>
        /// <param name="sendingPacketTypeStr">发送的消息类型  The sending packet type</param>
        /// <param name="expectedReturnPacketTypeStr">预期返回的消息类型  The packet type which will be used for the reply</param>
        /// <param name="returnPacketTimeOutMilliSeconds">消息返回的超时时间  A timeout in milliseconds after which if not reply is received will
        /// throw an ExpectedReturnTimeoutException.</param>
        /// <param name="sendObject">发送的对象  The object to send</param>
        /// <param name="sendOptions">发送时的收发参数  SendReceiveOptions to use when sending</param>
        /// <param name="receiveOptions">接收时的收发参数  SendReceiveOptions used when receiving the return object</param>
        /// <returns>The requested return object</returns>
        public returnObjectType SendReceiveObject<sendObjectType, returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, sendObjectType sendObject, SendReceiveOptions sendOptions, SendReceiveOptions receiveOptions)
        {
            long sentPacketSequenceNumber;
            return SendReceiveObject<sendObjectType, returnObjectType>(sendingPacketTypeStr, expectedReturnPacketTypeStr, returnPacketTimeOutMilliSeconds, sendObject, sendOptions, receiveOptions, out sentPacketSequenceNumber);
        }

        /// <summary>
        /// Send an object using the provided <see cref="SendReceiveOptions"/> and wait for a returned object using provided
        /// 发送并接收数据 （同步方法）
        /// </summary>
        /// <typeparam name="sendObjectType">发送的类的类型 The sending object type, i.e. string, int[], etc</typeparam>
        /// <typeparam name="returnObjectType">返回的类的类型  The type of return object</typeparam>
        /// <param name="sendingPacketTypeStr">发送的消息类型  The sending packet type</param>
        /// <param name="expectedReturnPacketTypeStr">预期返回的消息类型  The packet type which will be used for the reply</param>
        /// <param name="returnPacketTimeOutMilliSeconds">消息返回的超时时间  A timeout in milliseconds after which if not reply is received will
        /// throw an ExpectedReturnTimeoutException.</param>
        /// <param name="sendObject">发送的对象  The object to send</param>
        /// <param name="sendOptions">发送时的收发参数  SendReceiveOptions to use when sending</param>
        /// <param name="receiveOptions">接收时的收发参数  SendReceiveOptions used when receiving the return object</param>
        /// <param name="sentPacketSequenceNumber">数据包的顺序号The sequence number of the packet sent</param>
        /// <returns>The requested return object</returns>
        public returnObjectType SendReceiveObject<sendObjectType, returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, sendObjectType sendObject, SendReceiveOptions sendOptions, SendReceiveOptions receiveOptions, out long sentPacketSequenceNumber)
        {
            if (sendingPacketTypeStr == expectedReturnPacketTypeStr)
                throw new ArgumentException("The provided sendingPacketTypeStr and expectedReturnPacketTypeStr parameters must be different.");

            returnObjectType returnObject = default(returnObjectType);

            bool remotePeerDisconnectedDuringWait = false;
            AutoResetEvent returnWaitSignal = new AutoResetEvent(false);

            #region SendReceiveDelegate
            NetworkComms.PacketHandlerCallBackDelegate<returnObjectType> SendReceiveDelegate = (packetHeader, sourceConnection, incomingObject) =>
            {
                returnObject = incomingObject;
                returnWaitSignal.Set();
            };

            //We use the following delegate to quickly force a response timeout if the remote end disconnects
            //如果远端掉线 我们使用下面的委托马上触发等待超时
            NetworkComms.ConnectionEstablishShutdownDelegate SendReceiveShutDownDelegate = (sourceConnection) =>
            {
                remotePeerDisconnectedDuringWait = true;
                returnObject = default(returnObjectType);
                returnWaitSignal.Set();
            };
            #endregion

            if (sendOptions == null) sendOptions = ConnectionDefaultSendReceiveOptions;
            if (receiveOptions == null) receiveOptions = ConnectionDefaultSendReceiveOptions;

            AppendShutdownHandler(SendReceiveShutDownDelegate);
            AppendIncomingPacketHandler(expectedReturnPacketTypeStr, SendReceiveDelegate, receiveOptions);

            //Check to see if we already have a packet
            //检测我们是否已经获得数据包
            Packet sendObjectAsPacket = sendObject as Packet;
            if (sendObjectAsPacket == null)
            {
                using (Packet sendPacket = new Packet(sendingPacketTypeStr, expectedReturnPacketTypeStr, sendObject, sendOptions))
                    SendPacket<sendObjectType>(sendPacket, out sentPacketSequenceNumber);
            }
            else
            {
                if (sendObjectAsPacket.PacketHeader.PacketType != sendingPacketTypeStr)
                    throw new ArgumentException("Unable to send object of type Packet if the PacketHeader.PacketType and sendingPacketType do not match.");

                SendPacket<sendObjectType>(sendObjectAsPacket, out sentPacketSequenceNumber);
            }

            //We wait for the return data here
            //等待返回的数据
#if NET2
            if (!returnWaitSignal.WaitOne(returnPacketTimeOutMilliSeconds, false))
#else
            if (!returnWaitSignal.WaitOne(returnPacketTimeOutMilliSeconds))
#endif
            {
                RemoveIncomingPacketHandler(expectedReturnPacketTypeStr, SendReceiveDelegate);
                throw new ExpectedReturnTimeoutException("Timeout occurred after " + returnPacketTimeOutMilliSeconds.ToString() + "ms waiting for response packet of type '" + expectedReturnPacketTypeStr + "'.");
            }

            RemoveIncomingPacketHandler(expectedReturnPacketTypeStr, SendReceiveDelegate);
            RemoveShutdownHandler(SendReceiveShutDownDelegate);

            if (remotePeerDisconnectedDuringWait)
                throw new ConnectionShutdownException("Remote end closed connection before data was successfully returned.");
            else
                return returnObject;
        }

        /// <summary>
        /// Send an empty packet using the connection default <see cref="SendReceiveOptions"/> and wait for a returned object again
        /// using default <see cref="SendReceiveOptions"/>. Useful to request an object when there is no need to send anything.
        /// 发送空的数据包给对方 使用默认的收发参数 并等待返回的数据包
        /// 当我们从对方获取某个对象，但不需要发送对象给对方时使用
        /// </summary>
        /// <typeparam name="returnObjectType">返回的对象的类型The type of return object</typeparam>
        /// <param name="sendingPacketTypeStr">消息类型 The sending packet type</param>
        /// <param name="expectedReturnPacketTypeStr">期待返回的消息类型  The packet type which will be used for the reply</param>
        /// <param name="returnPacketTimeOutMilliSeconds">超时时间  A timeout in milliseconds after which if not reply is received will throw
        /// an ExpectedReturnTimeoutException.</param>
        /// <returns></returns>
        public returnObjectType SendReceiveObject<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds)
        {
            return SendReceiveObject<object, returnObjectType>(sendingPacketTypeStr, expectedReturnPacketTypeStr, returnPacketTimeOutMilliSeconds, null, null, null);
        }

        /// <summary>
        /// Send an empty packet using the connection default <see cref="SendReceiveOptions"/> and wait for a returned object again using default <see cref="SendReceiveOptions"/>. Usefull to request an object when there is no need to send anything.
        /// 发送空的数据包给对方 使用默认的收发参数 并等待返回的数据包
        /// 当我们从对方获取某个对象，但不需要发送对象给对方时使用
        /// </summary>
        /// <typeparam name="returnObjectType">返回的对象的类型 The type of return object</typeparam>
        /// <param name="sendingPacketTypeStr">消息类型 The sending packet type</param>
        /// <param name="expectedReturnPacketTypeStr">期待返回的消息类型 The packet type which will be used for the reply</param>
        /// <param name="returnPacketTimeOutMilliSeconds">超时时间 A timeout in milliseconds after which if not reply is received will throw an ExpectedReturnTimeoutException.</param>
        /// <param name="sentPacketSequenceNumber">包的顺序号  The sequence number of the packet sent</param>
        /// <returns></returns>
        public returnObjectType SendReceiveObject<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, out long sentPacketSequenceNumber)
        {
            return SendReceiveObject<object, returnObjectType>(sendingPacketTypeStr, expectedReturnPacketTypeStr, returnPacketTimeOutMilliSeconds, null, null, null, out sentPacketSequenceNumber);
        }

        /// <summary>
        /// Closes the connection and trigger any associated shutdown delegates.
        /// 关闭连接并触发相关的委托
        /// </summary>
        /// <param name="closeDueToError">关闭 是否是由于错误  Closing a connection due an error possibly requires a few extra steps.</param>
        /// <param name="logLocation">可选的调试参数  Optional debug parameter.</param>
        )
        {
            try
            {
                if (NetworkComms.LoggingEnabled)
                {
                    if (closeDueToError)
                        NetworkComms.Logger.Debug("Closing connection with " + ConnectionInfo + " due to error from [" + logLocation.ToString() + "].");
                    else
                        NetworkComms.Logger.Debug("Closing connection with " + ConnectionInfo + " from [" + logLocation.ToString() + "].");
                }

                ConnectionInfo.NoteConnectionShutdown();

                //Set possible error cases 设置可能的错误情况

                if (closeDueToError)
                {
                    connectionSetupException = true;
                    connectionSetupExceptionStr = "Connection was closed during setup from [" + logLocation.ToString() + "].";
                }

                //Ensure we are not waiting for a connection to be established if we have died due to error
                //给connectionSetupWait信号 确保连接关闭后  系统不再等待连接的创建
                connectionSetupWait.Set();

                //Call any connection specific close requirements
                //关闭连接的具体方法
                CloseConnectionSpecific(closeDueToError, logLocation);

#if !NETFX_CORE
                try
                {
                    //If we are calling close from the listen thread we are actually in the same thread
                    //We must guarantee the listen thread stops even if that means we need to nuke it
                    //If we did not we may not be able to shutdown properly.
                    //如果我们从监听线程调用Close，我们实际上是在同一个线程
                    //我们必须保证监听线程停止
                    //否则我们可能无法正常关闭

                    if (incomingDataListenThread != null && incomingDataListenThread != Thread.CurrentThread && (incomingDataListenThread.ThreadState == System.Threading.ThreadState.WaitSleepJoin || incomingDataListenThread.ThreadState == System.Threading.ThreadState.Running))
                    {
                        //If we have made it this far we give the thread a further 50ms to finish before nuking.
                        //如果我们这么做,我们给线程50ms来完成相应的事情
                        ))
                        {
                            incomingDataListenThread.Abort();
                            if (NetworkComms.LoggingEnabled && ConnectionInfo != null) NetworkComms.Logger.Warn("Incoming data listen thread with " + ConnectionInfo + " aborted.");
                        }
                    }
                }
                catch (Exception)
                {

                }
#endif
                //Close connection my get called multiple times for a given connection depending on the reason for being closed
                //根据关闭的原因 我们可能会多次调用 Close connection
                bool firstClose = NetworkComms.RemoveConnectionReference(this);

                try
                {
                    //Almost there
                    //Last thing is to call any connection specific shutdown delegates
                    //最后来调用连接指定关闭委托
                    if (firstClose && ConnectionSpecificShutdownDelegate != null)
                    {
                        if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Debug("Triggered connection specific shutdown delegates with " + ConnectionInfo);
                        ConnectionSpecificShutdownDelegate(this);
                    }
                }
                catch (Exception ex)
                {
                    LogTools.LogException(ex, "ConnectionSpecificShutdownDelegateError", "Error while executing connection specific shutdown delegates for " + ConnectionInfo + ". Ensure any shutdown exceptions are caught in your own code.");
                }

                try
                {
                    //Last but not least we call any global connection shutdown delegates
                    //调用全局连接关闭委托
                    if (firstClose && NetworkComms.globalConnectionShutdownDelegates != null)
                    {
                        if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Debug("Triggered global shutdown delegates with " + ConnectionInfo);
                        NetworkComms.globalConnectionShutdownDelegates(this);
                    }
                }
                catch (Exception ex)
                {
                    LogTools.LogException(ex, "GlobalConnectionShutdownDelegateError", "Error while executing global connection shutdown delegates for " + ConnectionInfo + ". Ensure any shutdown exceptions are caught in your own code.");
                }
            }
            catch (Exception ex)
            {
#if !NETFX_CORE
                if (ex is ThreadAbortException)
                { /*Ignore the threadabort exception if we had to nuke a thread*/ }
                else
#endif
                    LogTools.LogException(ex, "NCError_CloseConnection", "Error closing connection with " + ConnectionInfo + ". Close called from " + logLocation.ToString() + (closeDueToError ? " due to error." : "."));

                //We try to rethrow where possible but CloseConnection could very likely be called from within networkComms so we just have to be happy with a log here
                //记录日志
            }
        }

        /// <summary>
        /// Every connection will probably have to perform connection specific shutdown tasks. This is called before the global
        /// connection close tasks.
        /// 连接关闭的具体方法
        /// </summary>
        /// <param name="closeDueToError">Closing a connection due an error possibly requires a few extra steps.</param>
        /// <param name="logLocation">Optional debug parameter for determining the location of the close.</param>
        );

        /// <summary>
        /// Uses the current connection and returns a bool dependant on the remote end responding to a SendReceiveObject call
        /// within the default <see cref="NetworkComms.ConnectionAliveTestTimeoutMS"/>
        /// 连接是否为活动状态
        /// </summary>
        /// <returns>True if the remote end responds within <see cref="NetworkComms.ConnectionAliveTestTimeoutMS"/> otherwise false</returns>
        public bool ConnectionAlive()
        {
            return ConnectionAlive(NetworkComms.ConnectionAliveTestTimeoutMS);
        }

        /// <summary>
        /// Uses the current connection and returns a bool dependant on the remote end responding to a SendReceiveObject call
        /// within the provided aliveRespondTimeoutMS.
        ///  连接是否为活动状态
        /// </summary>
        /// <param name="aliveRespondTimeoutMS">超时时间  The time to wait in milliseconds before returning false</param>
        /// <returns>True if the remote end responds within the provided aliveRespondTimeoutMS</returns>
        public bool ConnectionAlive(int aliveRespondTimeoutMS)
        {
            long responseTime;
            return ConnectionAlive(aliveRespondTimeoutMS, out responseTime);
        }

        /// <summary>
        /// Uses the current connection and returns a bool dependant on the remote end responding to a SendReceiveObject call
        /// within the provided aliveRespondTimeoutMS
        /// 连接是否为活动状态
        /// </summary>
        /// <param name="aliveRespondTimeoutMS">超时时间 The time to wait in milliseconds before returning false</param>
        /// <param name="responseTimeMS">回复时间  The number of milliseconds taken for a successful response to be received</param>
        /// <returns></returns>
        public bool ConnectionAlive(int aliveRespondTimeoutMS, out long responseTimeMS)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            responseTimeMS = long.MaxValue;

            if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Enabled)
            {
                //We wait for TCP connections to be established
                //等待TCP连接创建
                if (ConnectionInfo.ConnectionType == ConnectionType.TCP && ConnectionInfo.ConnectionState != ConnectionState.Established)
                {
                    if ((DateTime.Now - ConnectionInfo.ConnectionCreationTime).Milliseconds > NetworkComms.ConnectionEstablishTimeoutMS)
                    {
                        CloseConnection();
                        return false;
                    }
                    else
                        return true;
                }
                else
                {
                    try
                    {
                        timer.Start();
                        SendReceiveObject<], NetworkComms.InternalFixedSendReceiveOptions, NetworkComms.InternalFixedSendReceiveOptions);
                        timer.Stop();

                        responseTimeMS = timer.ElapsedMilliseconds;

                        if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("ConnectionAliveTest success, response in " + timer.ElapsedMilliseconds.ToString() + "ms.");

                        return true;
                    }
                    catch (Exception)
                    {
                        CloseConnection();
                        return false;
                    }
                }
            }
            else
                return false;
        }

        /// <summary>
        /// Send the provided packet to the remoteEndPoint. Waits for receive confirmation if required.
        /// 发送数据包到远端点上  等待接收确认消息（如果需要）
        /// </summary>
        /// <typeparam name="packetPayloadObjectType">The type of object encapsulated by the provided packet</typeparam>
        /// <param name="packet">The packet to send</param>
        public void SendPacket<packetPayloadObjectType>(IPacket packet)
        {
            long packetSequenceNumber;
            SendPacket<packetPayloadObjectType>(packet, out packetSequenceNumber);
        }

        /// <summary>
        /// Send the provided packet to the remoteEndPoint. Waits for receive confirmation if required.
        /// 发送数据包到远端点上  等待接收确认消息（如果需要）
        /// </summary>
        /// <typeparam name="packetPayloadObjectType">The type of object encapsulated by the provided packet</typeparam>
        /// <param name="packet">数据包  The packet to send</param>
        /// <param name="packetSequenceNumber">顺序号  The sequence number of the packet sent</param>
        public void SendPacket<packetPayloadObjectType>(IPacket packet, out long packetSequenceNumber)
        {
            if (NetworkComms.LoggingEnabled)
            {
                string packetDataMD5 = "";
                if (packet.PacketHeader.ContainsOption(PacketHeaderStringItems.CheckSumHash))
                    packetDataMD5 = packet.PacketHeader.GetOption(PacketHeaderStringItems.CheckSumHash);

                NetworkComms.Logger.Trace("Entering packet send of '" + packet.PacketHeader.PacketType + "' packetType to " + ConnectionInfo + (packetDataMD5 == "" ? "" : ". PacketCheckSum="+packetDataMD5));
            }

            if (packet.PacketHeader.ContainsOption(PacketHeaderStringItems.ReceiveConfirmationRequired) &&
                ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Disabled)
                throw new ArgumentException("Provided sendReceiveOptions specified ReceiveConfirmationRequired which is invalid for" +
            "connections which do not enable the application protocol. Please check provided sendReceiveOptions including global defaults and try again.");

            //Multiple threads may try to send packets at the same time so wait one at a time here
            //同步锁  多防止个线程可能同时发送数据包
            lock (sendLocker)
            {
                //We don't allow sends on a closed connection
                //不允许在关闭的连接上发送数据
                if (ConnectionInfo.ConnectionState == ConnectionState.Shutdown) throw new CommunicationException("Attempting to send packet on connection which has been closed or is currently closing.");

                //Set packet sequence number inside sendLocker
                //设置数据包的顺序号
                //Increment the global counter as well to ensure future connections with the same host can not create duplicates
                //顺序号自增长 确保不会重复
                Interlocked.Increment(ref NetworkComms.totalPacketSendCount);
                packetSequenceNumber = packetSequenceCounter++;
                packet.PacketHeader.SetOption(PacketHeaderLongItems.PacketSequenceNumber, packetSequenceNumber);

                //string confirmationCheckSum = "";
                long expectedPacketSequenceConfirmationNumber = packetSequenceNumber;
                AutoResetEvent confirmationWaitSignal = new AutoResetEvent(false);
                bool remotePeerDisconnectedDuringWait = false;

                #region Delegates
                //Specify a delegate we may use if we require receive confirmation
                //指定一个委托，如果需要接收确认消息
                NetworkComms.PacketHandlerCallBackDelegate<long> confirmationDelegate = (packetHeader, connectionInfo, incomingSequenceIdentifier) =>
                {
                    //A better method for confirming packets is to use the sending sequence number
                    //确认数据包一个好的方法 即使用发送的顺序号
                    if (incomingSequenceIdentifier == expectedPacketSequenceConfirmationNumber)
                        confirmationWaitSignal.Set();
                };

                //We use the following delegate to quickly force a response timeout if the remote end disconnects during a send/wait
                //如果对方掉线 设置立即超时
                NetworkComms.ConnectionEstablishShutdownDelegate ConfirmationShutDownDelegate = (connectionInfo) =>
                {
                    remotePeerDisconnectedDuringWait = true;
                    confirmationWaitSignal.Set();
                };
                #endregion

                try
                {
                    #region Prepare For Confirmation and Possible Validation
                    //Add the confirmation handler if required
                    //如果需要添加确认收到数据包处理器
                    if (packet.PacketHeader.ContainsOption(PacketHeaderStringItems.ReceiveConfirmationRequired))
                    {
                        AppendIncomingPacketHandler(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Confirmation), confirmationDelegate, NetworkComms.InternalFixedSendReceiveOptions);
                        AppendShutdownHandler(ConfirmationShutDownDelegate);
                    }

                    //If this packet is not a checkSumFailResend
                    //如果此数据包的类型不是 checkSumFailResend
                    if (NetworkComms.EnablePacketCheckSumValidation && packet.PacketHeader.PacketType != Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.CheckSumFailResend))
                    {
                        //We only want to keep packets when they are under some provided threshold
                        //otherwise this becomes a quick 'memory leak'
                        //获取数据包的哈希值 数据包的大小不能大于设定值（NetworkComms.CheckSumMismatchSentPacketCacheMaxByteLimit）
                        if (packet.PacketData.Length < NetworkComms.CheckSumMismatchSentPacketCacheMaxByteLimit)
                        {
                            lock (sentPacketsLocker)
                            {
                                var hash = packet.PacketHeader.GetOption(PacketHeaderStringItems.CheckSumHash);

                                if (!sentPackets.ContainsKey(hash))
                                    sentPackets.Add(hash, new SentPacket(packet));
                            }
                        }
                    }
                    #endregion

                    SendPacketSpecific(packet);

                    #region SentPackets Cleanup
                    //If sent packets is greater than 40 we delete anything older than a minute
                    //如果发送的数据包大于40 我们删除一分钟之前发送的数据
                    lock (sentPacketsLocker)
                    {
                        )
                        {
                            Dictionary<string, SentPacket> newSentPackets = new Dictionary<string, SentPacket>();
                            DateTime thresholdTime = DateTime.Now.AddMinutes(-NetworkComms.MinimumSentPacketCacheTimeMinutes);
                            foreach (var storedPacket in sentPackets)
                            {
                                if (storedPacket.Value.SentPacketCreationTime >= thresholdTime)
                                    newSentPackets.Add(storedPacket.Key, storedPacket.Value);
                            }

                            sentPackets = newSentPackets;
                            NetworkComms.LastSentPacketCacheCleanup = DateTime.Now;
                        }
                    }
                    #endregion

                    #region Wait For Confirmation If Required
                    //If we required receive confirmation we now wait for that confirmation
                    //如果我们需要对方确认收到消息  在此处等待
                    if (packet.PacketHeader.ContainsOption(PacketHeaderStringItems.ReceiveConfirmationRequired))
                    {
                        if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace(" ... waiting for receive confirmation packet.");

#if NET2
                        if (!(confirmationWaitSignal.WaitOne(NetworkComms.PacketConfirmationTimeoutMS, false)))
#else
                        if (!(confirmationWaitSignal.WaitOne(NetworkComms.PacketConfirmationTimeoutMS)))
#endif
                            throw new ConfirmationTimeoutException("Confirmation packet timeout.");

                        if (remotePeerDisconnectedDuringWait)
                            throw new ConfirmationTimeoutException("Remote end closed connection before confirmation packet was returned.");
                        else
                        {
                            if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace(" ... confirmation packet received.");
                        }
                    }
                    #endregion

                    //Update the traffic time as late as possible in case there is a problem
                    //更新ConnectionInfo中的数据包的传输时间
                    ConnectionInfo.UpdateLastTrafficTime();
                }
                catch (ConfirmationTimeoutException)
                {
                    //Confirmation timeout there is no need to close the connection as this
                    //does not necessarily mean there is a connection problem
                    //确认消息超时异常
                    throw;
                }
                catch (CommunicationException)
                {
                    //We close the connection due to communication exceptions
                    //通信异常
                    CloseConnection();
                    throw;
                }
                catch (TimeoutException ex)
                {

                    //We close the connection due to communication exceptions
                    //超时异常
                    if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Warn("Timeout exception for connection " + this.ConnectionInfo + (ex.Message != null ? ". " +ex.Message : "."));

                    CloseConnection();
                    throw new ConnectionSendTimeoutException(ex.ToString());
                }
                catch (Exception ex)
                {
                    //We close the connection due to communication exceptions
                    //异常
                    CloseConnection();
                    throw new CommunicationException(ex.ToString());
                }
                finally
                {
                    if (packet.PacketHeader.ContainsOption(PacketHeaderStringItems.ReceiveConfirmationRequired))
                    {
                        //Clean-up our delegates
                        //清理我们的委托
                        RemoveIncomingPacketHandler(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Confirmation), confirmationDelegate);
                        RemoveShutdownHandler(ConfirmationShutDownDelegate);
                    }
                }
            }

            if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Completed packet send of '" + packet.PacketHeader.PacketType + "' packetType to " + ConnectionInfo);
        }

        /// <summary>
        /// Implementation for sending a null packets on this connection type. Used for ensuring a connection
        /// is not terminated by an intermediary switch/router due to inactivity.
        /// 发送空数据包
        /// </summary>
        private void SendNullPacket()
        {
            //We don't send null packets for UDP
            //在 UDP连接上不发送空数据包
            if (ConnectionInfo.ConnectionType == ConnectionType.UDP)
                return;

            //We can't send null packets if the application layer is disabled
            //as we have no way to distinguish them on the receiving side
            //如果应用层协议禁用 不发送空数据包 因为此时我们没有方法在接收端识别出他们
            if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Disabled)
            {
                if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Ignoring null packet send to " + ConnectionInfo + " as the application layer protocol is disabled.");
                return;
            }

            try
            {
                //Only once the connection has been established do we send null packets
                //只有在连接创建完成后，我们发送空数据包
                if (ConnectionInfo.ConnectionState == ConnectionState.Established)
                {
                    //Multiple threads may try to send packets at the same time so we need this lock to prevent a thread cross talk
                    //同步锁 防止多个线程同时发送数据包
                    lock (sendLocker)
                    {
                        if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Sending null packet to " + ConnectionInfo);

                        //Send a single 0 byte
                        //发送一个单字节数据
                        double maxSendTimePerKB = double.MaxValue;
                        if (!NetworkComms.DisableConnectionSendTimeouts)
                        {
                            if (SendTimesMSPerKBCache.Count > MinNumSendsBeforeConnectionSpecificSendTimeout)
                                maxSendTimePerKB = Math.Max(MinimumMSPerKBSendTimeout, SendTimesMSPerKBCache.CalculateMean() + NumberOfStDeviationsForWriteTimeout * SendTimesMSPerKBCache.CalculateStdDeviation());
                            else
                                maxSendTimePerKB = DefaultMSPerKBSendTimeout;
                        }

                        StreamTools.StreamSendWrapper[] streamsToSend = new StreamTools.StreamSendWrapper[]
                        {
                             }), true))
                        }; 

                        SendStreams(streamsToSend, maxSendTimePerKB, );

                        //Update the traffic time after we have written to netStream
                        //更新传输时间
                        ConnectionInfo.UpdateLastTrafficTime();
                    }
                }

                //If the connection is shutdown we should call close
                //连接关闭 调用CloseConnection方法
                );
            }
            catch (Exception)
            {
                CloseConnection();
            }
        }

        /// <summary>
        /// Send the provided packet
        /// 发送数据包的具体方法
        /// </summary>
        /// <param name="packet"></param>
        private void SendPacketSpecific(IPacket packet)
        {
            byte[] headerBytes;

            //Serialise the header
            //序列化包头
            if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Enabled)
                headerBytes = packet.SerialiseHeader(NetworkComms.InternalFixedSendReceiveOptions);
            else
            {
                //If this connection does not use the application layer protocol we need to check a few things
                //如果连接没有使用应用层协议 我们需要做一些检测
                headerBytes = ];

                if (packet.PacketHeader.PacketType != Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Unmanaged))
                    throw new UnexpectedPacketTypeException("Only 'Unmanaged' packet types can be used if the NetworkComms.Net application layer protocol is disabled.");

                )
                    throw new NotSupportedException("Sending a zero length array if the NetworkComms.Net application layer protocol is disabled is not supported.");
            }

            double maxSendTimePerKB = double.MaxValue;
            if (!NetworkComms.DisableConnectionSendTimeouts)
            {
                if (SendTimesMSPerKBCache.Count > MinNumSendsBeforeConnectionSpecificSendTimeout)
                    maxSendTimePerKB = Math.Max(MinimumMSPerKBSendTimeout, SendTimesMSPerKBCache.CalculateMean() + NumberOfStDeviationsForWriteTimeout * SendTimesMSPerKBCache.CalculateStdDeviation());
                else
                    maxSendTimePerKB = DefaultMSPerKBSendTimeout;
            }

            if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Debug("Sending a packet of type '" + packet.PacketHeader.PacketType + "' to " +
                ConnectionInfo + " containing " + headerBytes.Length.ToString() + " header bytes and " + packet.PacketData.Length.ToString() + " payload bytes. Allowing " +
                maxSendTimePerKB.ToString("0.0##") + " ms/KB for send.");

            DateTime startTime = DateTime.Now;

            StreamTools.StreamSendWrapper[] streamsToSend = new StreamTools.StreamSendWrapper[]
            { new StreamTools.StreamSendWrapper(new StreamTools.ThreadSafeStream(new MemoryStream(headerBytes), true)),
                packet.PacketData};

            ;
            foreach (StreamTools.StreamSendWrapper stream in streamsToSend)
                totalBytesToSend += stream.Length;

            //Send the streams 发送数据流
            double[] timings = SendStreams(streamsToSend, maxSendTimePerKB, totalBytesToSend);

            //Record the timings 记录时间
            ;
            ; i < timings.Length; i++)
            {
                timingsSum += timings[i];
                SendTimesMSPerKBCache.AddValue(timings[i], streamsToSend[i].Length);
            }

            SendTimesMSPerKBCache.TrimList(MaxNumSendTimes);

            if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace(" ... " + (totalBytesToSend / 1024.0).ToString("0.000") + "KB sent at average of " + ((totalBytesToSend / 1024.0) / (DateTime.Now - startTime).TotalSeconds).ToString("0.000") + "KB/s. Current:" + (timingsSum / timings.Length).ToString("0.00") + " ms/KB, Connection Avg:" + SendTimesMSPerKBCache.CalculateMean().ToString("0.00") + " ms/KB.");
        }

        /// <summary>
        /// Connection specific implementation for sending data on this connection type.
        /// Each StreamSendWrapper[] represents a single expected packet.
        /// 发送数据流
        /// </summary>
        /// <param name="streamsToSend">数据流   The streams which need to be sent</param>
        /// <param name="maxSendTimePerKB">每KB数据最长的发送时间  The maximum time to allow per KB before a write timeout exception.</param>
        /// <param name="totalBytesToSend">总共需要发送的字节数量  A precalculated sum of streams.Length</param>
        /// <returns>Should return double[] which represents the milliseconds per byte written for each StreamSendWrapper</returns>
        protected abstract double[] SendStreams(StreamTools.StreamSendWrapper[] streamsToSend, double maxSendTimePerKB, long totalBytesToSend);

        /// <summary>
        /// Dispose of the connection. Recommended usage is to call CloseConnection instead.
        /// 释放连接  推荐使用CloseConnection替代
        /// </summary>
        public void Dispose()
        {
            CloseConnection();

            try
            {
                ((IDisposable)connectionSetupWait).Dispose();
                ((IDisposable)connectionEstablishWait).Dispose();
            }
            catch (Exception) { }
        }
    }