/// <summary>    /// A TCP connection listener    /// TCP连接监听器    /// </summary>    public class TCPConnectionListener : ConnectionListenerBase    {#if WINDOWS_PHONE || NETFX_CORE        /// <summary>        /// The equivalent TCPListener class in windows phone        /// WP系统中与TCPListener类相对应的类        /// </summary>        StreamSocketListener listenerInstance;#else        /// <summary>        /// The .net TCPListener class.        /// .net中TCPListener类        /// </summary>        TcpListener listenerInstance;        /// <summary>        /// SSL options that are associated with this listener        /// 监听器相对应的SSL选项        /// </summary>        public SSLOptions SSLOptions { get; private set; }#endif        /// <summary>        /// Create a new instance of a TCP listener        /// 创建一个新的TCP监听器实例        /// </summary>        /// <param name="sendReceiveOptions">The SendReceiveOptions to use with incoming data on this listener  此监听器上接收进入的数据所使用的收发参数 </param>        /// <param name="applicationLayerProtocol">If enabled NetworkComms.Net uses a custom         /// application layer protocol to provide useful features such as inline serialisation,         /// transparent packet transmission, remote peer handshake and information etc. We strongly         /// recommend you enable the NetworkComms.Net application layer protocol.</param>        /// applicationLayerProtocol 应用层协议状态  我们强烈建议您启用此项，使得networkcomms能为您提供内部序列化，透明数据包传送，远程端点握手等功能。        /// 只有与其他语言进行通信时，此项才设置为禁用        /// <param name="allowDiscoverable">Determines if the newly created <see cref="ConnectionListenerBase"/> will be discoverable if <see cref="Tools.PeerDiscovery"/> is enabled.</param>        /// allowDiscoverable  是否允许被发现  此项与networkcomms中一项端点自动扫描功能有关        public TCPConnectionListener(SendReceiveOptions sendReceiveOptions,            ApplicationLayerProtocolStatus applicationLayerProtocol, bool allowDiscoverable = false)            :base(ConnectionType.TCP, sendReceiveOptions, applicationLayerProtocol, allowDiscoverable)        {#if !WINDOWS_PHONE && !NETFX_CORE            SSLOptions = new SSLOptions();#endif        }#if !WINDOWS_PHONE && !NETFX_CORE        /// <summary>        /// Create a new instance of a TCP listener        /// 创建一个新的TCP监听器实例        /// </summary>        /// <param name="sendReceiveOptions">The SendReceiveOptions to use with incoming data on this listener  此监听器上接收进入的数据所使用的收发参数 </param>        /// <param name="applicationLayerProtocol">If enabled NetworkComms.Net uses a custom         /// application layer protocol to provide useful features such as inline serialisation,         /// transparent packet transmission, remote peer handshake and information etc. We strongly         /// recommend you enable the NetworkComms.Net application layer protocol.</param>        /// applicationLayerProtocol 应用层协议状态  我们强烈建议您启用此项，使得networkcomms能为您提供内部序列化，透明数据包传送，远程端点握手等功能。        /// 只有与其他语言进行通信时，此项才设置为禁用        /// <param name="allowDiscoverable">Determines if the newly created <see cref="ConnectionListenerBase"/> will be discoverable if <see cref="Tools.PeerDiscovery"/> is enabled.</param>        /// allowDiscoverable  是否允许被发现  此项与networkcomms中一项端点自动扫描功能有关        public TCPConnectionListener(SendReceiveOptions sendReceiveOptions,            ApplicationLayerProtocolStatus applicationLayerProtocol, SSLOptions sslOptions, bool allowDiscoverable = false)            : base(ConnectionType.TCP, sendReceiveOptions, applicationLayerProtocol, allowDiscoverable)        {            this.SSLOptions = sslOptions;        }#endif        /// <inheritdoc />        internal override void StartListening(EndPoint desiredLocalListenEndPoint, bool useRandomPortFailOver)        {            if (desiredLocalListenEndPoint.GetType() != typeof(IPEndPoint)) throw new ArgumentException("Invalid desiredLocalListenEndPoint type provided.", "desiredLocalListenEndPoint");            if (IsListening) throw new InvalidOperationException("Attempted to call StartListening when already listening.");            IPEndPoint desiredLocalListenIPEndPoint = (IPEndPoint)desiredLocalListenEndPoint;            try            {#if WINDOWS_PHONE || NETFX_CORE                listenerInstance = new StreamSocketListener();                listenerInstance.ConnectionReceived += newListenerInstance_ConnectionReceived;                listenerInstance.BindEndpointAsync(new Windows.Networking.HostName(desiredLocalListenIPEndPoint.Address.ToString()), desiredLocalListenIPEndPoint.Port.ToString()).AsTask().Wait();#else                listenerInstance = new TcpListener(desiredLocalListenIPEndPoint);                listenerInstance.Start();                listenerInstance.BeginAcceptTcpClient(TCPConnectionReceivedAsync, null);#endif            }            catch (SocketException)            {                //If the port we wanted is not available                //如果我们希望监听的端口已经被占用  useRandomPortFailOver(是否随机指定一个新端口)                if (useRandomPortFailOver)                {                    try                    {#if WINDOWS_PHONE || NETFX_CORE                        listenerInstance.BindEndpointAsync(new Windows.Networking.HostName(desiredLocalListenIPEndPoint.Address.ToString()), "").AsTask().Wait(); #else                        listenerInstance = new TcpListener(desiredLocalListenIPEndPoint.Address, 0);                        listenerInstance.Start();                        listenerInstance.BeginAcceptTcpClient(TCPConnectionReceivedAsync, null);#endif                    }                    catch (SocketException)                    {                        //If we get another socket exception this appears to be a bad IP. We will just ignore this IP                        //如果我们重新指定端口，还是没有监听成功，则可能是IP地址的问题                        if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Error("It was not possible to open a random port on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");                        throw new CommsSetupShutdownException("It was not possible to open a random port on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");                    }                }                else                {                    if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Error("It was not possible to open port #" + desiredLocalListenIPEndPoint.Port.ToString() + " on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");                    throw new CommsSetupShutdownException("It was not possible to open port #" + desiredLocalListenIPEndPoint.Port.ToString() + " on " + desiredLocalListenIPEndPoint.Address + ". This endPoint may not support listening or possibly try again using a different port.");                }            }#if WINDOWS_PHONE || NETFX_CORE            this.LocalListenEndPoint = new IPEndPoint(desiredLocalListenIPEndPoint.Address, int.Parse(listenerInstance.Information.LocalPort));  #else            this.LocalListenEndPoint = (IPEndPoint)listenerInstance.LocalEndpoint;#endif            this.IsListening = true;        }        /// <inheritdoc />        internal override void StopListening()        {            IsListening = false;            try            {#if WINDOWS_PHONE || NETFX_CORE                listenerInstance.Dispose();#else                listenerInstance.Stop();#endif            }            catch (Exception) { }        }#if WINDOWS_PHONE || NETFX_CORE        private void newListenerInstance_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)        {            try            {                IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse(args.Socket.Information.LocalAddress.DisplayName.ToString()), int.Parse(args.Socket.Information.LocalPort));                IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(args.Socket.Information.RemoteAddress.DisplayName.ToString()), int.Parse(args.Socket.Information.RemotePort));                ConnectionInfo newConnectionInfo = new ConnectionInfo(ConnectionType.TCP, remoteEndPoint, localEndPoint, ApplicationLayerProtocol, this);                TCPConnection.GetConnection(newConnectionInfo, NetworkComms.DefaultSendReceiveOptions, args.Socket, true);            }            catch (ConfirmationTimeoutException)            {                //If this exception gets thrown its generally just a client closing a connection almost immediately after creation            }            catch (CommunicationException)            {                //If this exception gets thrown its generally just a client closing a connection almost immediately after creation            }            catch (ConnectionSetupException)            {                //If we are the server end and we did not pick the incoming connection up then tooo bad!            }            catch (SocketException)            {                //If this exception gets thrown its generally just a client closing a connection almost immediately after creation            }            catch (Exception ex)            {                //For some odd reason SocketExceptions don‘t always get caught above, so another check                if (ex.GetBaseException().GetType() != typeof(SocketException))                {                    //Can we catch the socketException by looking at the string error text?                    if (ex.ToString().StartsWith("System.Net.Sockets.SocketException"))                        LogTools.LogException(ex, "ConnectionSetupError_SE");                    else                        LogTools.LogException(ex, "ConnectionSetupError");                }            }        }#else        /// <summary>        /// Async method for handling up new incoming TCP connections        /// 处理新的TCP连接的异步方法        /// </summary>        private void TCPConnectionReceivedAsync(IAsyncResult ar)        {            if (!IsListening)                return;            try            {                TcpClient newTCPClient = listenerInstance.EndAcceptTcpClient(ar);                ConnectionInfo newConnectionInfo = new ConnectionInfo(ConnectionType.TCP, (IPEndPoint)newTCPClient.Client.RemoteEndPoint, (IPEndPoint)newTCPClient.Client.LocalEndPoint, ApplicationLayerProtocol, this);                if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Info("New incoming TCP connection from " + newConnectionInfo);                //We have to use our own thread pool here as the performance of the .Net one is awful                //此处我们使用了networkcomms自带的自定义线程池  其性能超越了.net自带的线程池                NetworkComms.IncomingConnectionEstablishThreadPool.EnqueueItem(QueueItemPriority.Normal, new WaitCallback((obj) =>                {                    #region Pickup The New Connection                    try                    {                        TCPConnection.GetConnection(newConnectionInfo, ListenerDefaultSendReceiveOptions, newTCPClient, true, SSLOptions);                    }                    catch (ConfirmationTimeoutException)                    {                        //If this exception gets thrown its generally just a client closing a connection almost immediately after creation                        //如果此处抛出异常  一般为客户端创建连接后立即关闭了连接                    }                    catch (CommunicationException)                    {                        //If this exception gets thrown its generally just a client closing a connection almost immediately after creation                        // //如果此处抛出异常  一般为客户端创建连接后立即关闭了连接                    }                    catch (ConnectionSetupException)                    {                        //If we are the server end and we did not pick the incoming connection up then tooo bad!                        //如果我们是服务器端 我们没有接收到进入的连接                    }                    catch (SocketException)                    {                        //If this exception gets thrown its generally just a client closing a connection almost immediately after creation                        // //如果此处抛出异常  一般为客户端创建连接后立即关闭了连接                    }                    catch (Exception ex)                    {                        //For some odd reason SocketExceptions don‘t always get caught above, so another check                        //由于一些未知的原因  上面的代码不能捕捉到所有的异常  所以我们还要尽行一些检测                        if (ex.GetBaseException().GetType() != typeof(SocketException))                        {                            //Can we catch the socketException by looking at the string error text?                            //通过检测字符型错误信息来捕捉 socket异常                            if (ex.ToString().StartsWith("System.Net.Sockets.SocketException"))                                LogTools.LogException(ex, "ConnectionSetupError_SE");                            else                                LogTools.LogException(ex, "ConnectionSetupError");                        }                    }                    #endregion                }), null);            }            catch (SocketException)            {                //如果此处抛出异常  一般为客户端创建连接后立即关闭了连接            }            catch (Exception ex)            {                //For some odd reason SocketExceptions don‘t always get caught above, so another check                //由于一些未知的原因  上面的代码不能捕捉到所有的异常   所以我们还要尽行一些检测                if (ex.GetBaseException().GetType() != typeof(SocketException))                {                    //Can we catch the socketException by looking at the string error text?                    if (ex.ToString().StartsWith("System.Net.Sockets.SocketException"))                        LogTools.LogException(ex, "ConnectionSetupError_SE");                    else                        LogTools.LogException(ex, "ConnectionSetupError");                }            }            finally            {                listenerInstance.BeginAcceptTcpClient(TCPConnectionReceivedAsync, null);            }        }#endif    }