原文网址： 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) { } } }
