networkComms.net2.3.1开源版本，基于gpl V3协议。因为不能公开3.x版本的源码，所以基于此版本进行学习。3.X版本进行了诸多改进和Bug修复，使用方法上两者相差不大。 

using System;using System.Collections.Generic;using System.Text;using System.Net;using System.Threading;using DPSBase;using System.Net.Sockets;namespace NetworkCommsDotNet{    /// <summary>    /// Connection对象  这个类是TcpConnection和 UDPConnnection连接类的父类    /// Connection由以下五个文件组成 大家注意到每个类前面都有个 partial关键字    /// ConnectionCreate.cs <1>    /// ConnectionDelegatesHandlers.cs <2>    /// ConnectionIncomingData.cs <3>    /// ConnectionSendClose.cs <4>    /// ConnectionStatic.cs  <5>    /// </summary>    /// 这部分主要是收发连接上的数据包的    public abstract partial class Connection : IDisposable    {        /// <summary>        /// Lockers for maintaing thread safe operation        /// </summary>        protected object sendLocker = new object();        /// <summary>        /// A comms math oject for tracking send times. Used to prevent send deadlocks.        /// Initialisated at 1000 milliseconds per KB write speed, corresponding with 1KB / second.        /// </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 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(string sendingPacketType, object 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(string sendingPacketType, object 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(string sendingPacketType, object objectToSend, SendReceiveOptions options)        {            long packetSequenceNumber;            SendPacket(new Packet(sendingPacketType, objectToSend, options), 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>        /// <param name="packetSequenceNumber">The sequence number of the packet sent</param>        public void SendObject(string sendingPacketType, object objectToSend, SendReceiveOptions options, out long packetSequenceNumber)        {            SendPacket(new Packet(sendingPacketType, objectToSend, options), out packetSequenceNumber);        }        /// <summary>        /// Send an empty packet using the provided packetType. Usefull for signalling.        /// </summary>        /// <param name="sendingPacketType">The sending packet type</param>        public void SendObject(string sendingPacketType) { SendObject(sendingPacketType, null); }        /// <summary>        /// Send an empty packet using the provided packetType. Usefull 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(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="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<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, object sendObject)         {             return SendReceiveObject<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="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<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, object sendObject, out long sentPacketSequenceNumber)        {            return SendReceiveObject<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 <see cref="SendReceiveOptions"/>.        /// </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="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<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, object sendObject, SendReceiveOptions sendOptions, SendReceiveOptions receiveOptions)        {            long sentPacketSequenceNumber;            return SendReceiveObject<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 <see cref="SendReceiveOptions"/>.        /// </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="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<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, object sendObject, SendReceiveOptions sendOptions, SendReceiveOptions receiveOptions, out long sentPacketSequenceNumber)        {            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);            using(Packet sendPacket = new Packet(sendingPacketTypeStr, expectedReturnPacketTypeStr, sendObject, sendOptions))                SendPacket(sendPacket, out sentPacketSequenceNumber);            //We wait for the return data here            if (!returnWaitSignal.WaitOne(returnPacketTimeOutMilliSeconds))            {                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 ExpectedReturnTimeoutException("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"/>. 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>        /// <returns></returns>        public returnObjectType SendReceiveObject<returnObjectType>(string sendingPacketTypeStr, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds) { return SendReceiveObject<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<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>        public void CloseConnection(bool closeDueToError, int logLocation = 0)        {            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.Set();                //Call any connection specific close requirements                CloseConnectionSpecific(closeDueToError, logLocation);                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.                    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 ythread a further 50ms to finish before nuking.                        if (!incomingDataListenThread.Join(50))                        {                            incomingDataListenThread.Abort();                            if (NetworkComms.LoggingEnabled && ConnectionInfo != null) NetworkComms.Logger.Warn("Incoming data listen thread with " + ConnectionInfo + " aborted.");                        }                    }                }                catch (Exception)                {                }                //Close connection my get called multiple times for a given connection depending on the reason for being closed                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)                {                    NetworkComms.LogError(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)                {                    NetworkComms.LogError(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 (ex is ThreadAbortException)                { /*Ignore the threadabort exception if we had to nuke a thread*/ }                else                    NetworkComms.LogError(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">ptional debug parameter.</param>        protected abstract void CloseConnectionSpecific(bool closeDueToError, int logLocation = 0);        /// <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 succesfull 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.ConnectionState == ConnectionState.Established))            {                if ((DateTime.Now - ConnectionInfo.ConnectionCreationTime).Milliseconds > NetworkComms.ConnectionEstablishTimeoutMS)                {                    CloseConnection(false, -11);                    return false;                }                else                    return true;            }            else            {                try                {                    timer.Start();                    byte[] returnValue = http://www.mamicode.com/SendReceiveObject<byte[]>(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.AliveTestPacket), Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.AliveTestPacket), aliveRespondTimeoutMS, new byte[1] { 0 }, NetworkComms.InternalFixedSendReceiveOptions, NetworkComms.InternalFixedSendReceiveOptions);                    timer.Stop();                    responseTimeMS = timer.ElapsedMilliseconds;                    if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("ConnectionAliveTest success, response in " + timer.ElapsedMilliseconds.ToString() + "ms.");                    return returnValue[0] == 1;                }                catch (Exception)                {                    CloseConnection(true, 46);                    return false;                }            }           }        /// <summary>        /// Send the provided packet to the remoteEndPoint. Waits for receive confirmation if required.        /// </summary>        /// <param name="packet">The packet to send</param>        internal void SendPacket(Packet packet)        {            long packetSequenceNumber;            SendPacket(packet, out packetSequenceNumber);        }        /// <summary>        /// Send the provided packet to the remoteEndPoint. Waits for receive confirmation if required.        /// </summary>        /// <param name="packet">The packet to send</param>        /// <param name="packetSequenceNumber">The sequence number of the packet sent</param>        internal void SendPacket(Packet 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));            }            //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 = "";                AutoResetEvent confirmationWaitSignal = new AutoResetEvent(false);                bool remotePeerDisconnectedDuringWait = false;                #region Delegates                //Specify a delegate we may use if we require receive confirmation                NetworkComms.PacketHandlerCallBackDelegate<string> confirmationDelegate = (packetHeader, connectionInfo, incomingString) =>                {                    //if (connectionInfo.NetworkIdentifier == this.ConnectionInfo.NetworkIdentifier && connectionInfo.RemoteEndPoint == this.ConnectionInfo.RemoteEndPoint)                    //{                    confirmationCheckSum = incomingString;                    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) =>                {                    //if (connectionInfo.NetworkIdentifier == this.ConnectionInfo.NetworkIdentifier && connectionInfo.RemoteEndPoint == this.ConnectionInfo.RemoteEndPoint)                    //{                    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                    if (NetworkComms.EnablePacketCheckSumValidation && packet.PacketHeader.PacketType != Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.CheckSumFailResend))                    {                        //We only want to keep packets when they are under some provided theshold                        //otherwise this becomes a quick ‘memory leak‘                        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                    lock (sentPacketsLocker)                    {                        if ((DateTime.Now - NetworkComms.LastSentPacketCacheCleanup).TotalMinutes > NetworkComms.MinimumSentPacketCacheTimeMinutes / 2)                        {                            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 (!(confirmationWaitSignal.WaitOne(NetworkComms.PacketConfirmationTimeoutMS)))                            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 incase there is a problem                    ConnectionInfo.UpdateLastTrafficTime();                }                catch (ConfirmationTimeoutException)                {                    //Confirmation timeout there is no need to close the connection as this                     //does not neccessarily mean there is a conneciton problem                    throw;                }                catch (CommunicationException)                {                    //We close the connection due to communication exceptions                    CloseConnection(true, 47);                    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(true, 48);                    throw new ConnectionSendTimeoutException(ex.ToString());                }                catch (Exception ex)                {                    //We close the connection due to communication exceptions                    CloseConnection(true, 49);                    throw new CommunicationException(ex.ToString());                }                finally                {                    if (packet.PacketHeader.ContainsOption(PacketHeaderStringItems.ReceiveConfirmationRequired))                    {                        //Cleanup 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>        /// Connection specific implementation for sending packets on this connection type. Will only be called from within a lock so method does not need to implement further thread safety.        /// </summary>        /// <param name="packet">The packet to send</param>        protected abstract void SendPacketSpecific(Packet packet);        /// <summary>        /// Connection specific implementation for sending a null packets on this connection type. Will only be called from within a lock so method does not need to implement further thread safety.        /// </summary>        protected abstract void SendNullPacket();        /// <summary>        /// Dispose of the connection. Recommended usage is to call CloseConnection instead.        /// </summary>        public void Dispose()        {            CloseConnection(false, -3);            try            {                ((IDisposable)connectionSetupWait).Dispose();                ((IDisposable)connectionEstablishWait).Dispose();            }            catch (Exception) { }        }    }}