basesocketconnectionhost.cs

来自「ActiveSync数据同步」· CS 代码 · 共 1,663 行 · 第 1/4 页

                            connection.Active = false;
                            connection.Socket.Close();
                        }

                        FireOnDisconnected(e);
                        
                    }

                    RemoveSocketConnection(connection);
                    DisposeAndNullConnection(ref connection);

                }
                catch (Exception ex)
                {
                    FireOnException(connection, ex);
                }

            }

        }

        #endregion
        
        #endregion

        #region Abstract Methods

        internal abstract void BeginReconnect(ClientSocketConnection connection);
        internal abstract void BeginSendToAll(ServerSocketConnection connection, byte[] buffer, bool includeMe);
        internal abstract void BeginSendTo(BaseSocketConnection connectionTo, byte[] buffer);
        internal abstract BaseSocketConnection GetConnectionById(long connectionId);
        internal abstract BaseSocketConnection[] GetConnectios();

        #endregion

        #endregion

        #region Connection Methods

        #region GetConnectionId

        internal long GetConnectionId()
        {
            return Interlocked.Increment(ref FConnectionId);
        }

        #endregion

        #region AddSocketConnection

        internal void AddSocketConnection(BaseSocketConnection socketConnection)
        {

            if (!Disposed)
            {

                FSocketConnectionsSync.AcquireWriterLock(Timeout.Infinite);

                try
                {
                    FSocketConnections.Add(socketConnection.ConnectionId, socketConnection);
                }
                finally
                {
                    FSocketConnectionsSync.ReleaseWriterLock();
                }

            }

        }

        #endregion

        #region RemoveSocketConnection

        internal void RemoveSocketConnection(BaseSocketConnection socketConnection)
        {

          if (!Disposed)
          {

              if (socketConnection != null)
              {


                  FSocketConnectionsSync.AcquireWriterLock(Timeout.Infinite);

                  try
                  {

                      FSocketConnections.Remove(socketConnection.ConnectionId);

                  }
                  finally
                  {
                      FSocketConnectionsSync.ReleaseWriterLock();

                      if (FSocketConnections.Count <= 0)
                      {
                          FWaitConnectionsDisposing.Set();
                      }

                  }

              }

        }

        }

        #endregion

        #region DisposeAndNullConnection

        internal void DisposeAndNullConnection(ref BaseSocketConnection connection)
        {

          if (connection != null)
          {
            connection.Dispose();
            connection = null;
          }

        }

        #endregion

        #region GetSocketConnections

        internal BaseSocketConnection[] GetSocketConnections()
        {

            BaseSocketConnection[] items = null;

            if (!Disposed)
            {

                FSocketConnectionsSync.AcquireReaderLock(Timeout.Infinite);

                try
                {
                    items = new BaseSocketConnection[FSocketConnections.Count];
                    FSocketConnections.Values.CopyTo(items, 0);
                }
                finally
                {
                    FSocketConnectionsSync.ReleaseReaderLock();
                }

            }

            return items;

        }

        #endregion

        #region GetSocketConnectionById

        internal BaseSocketConnection GetSocketConnectionById(long connectionId)
        {

            BaseSocketConnection item = null;

            if (!Disposed)
            {

                
                FSocketConnectionsSync.AcquireReaderLock(Timeout.Infinite);

                try
                {
                    item = FSocketConnections[connectionId];
                }
                finally
                {
                    FSocketConnectionsSync.ReleaseReaderLock();
                }

            }

            return item;

        }

        #endregion

        #region CheckSocketConnections

        private void CheckSocketConnections(Object stateInfo)
        {

            if (!Disposed)
            {

                //----- Disable timer event!
                FIdleTimer.Change(Timeout.Infinite, Timeout.Infinite);

                try
                {

                    //----- Get connections!
                    BaseSocketConnection[] items = GetSocketConnections();

                    if (items != null)
                    {

                        int loopSleep = 0;
                        
                        foreach (BaseSocketConnection cnn in items)
                        {

                            if (Disposed)
                            {
                                break;
                            }
                            
                            try
                            {

                                if (cnn != null)
                                {

                                    //----- Check the idle timeout!
                                    if (DateTime.Now > (cnn.LastAction.AddMilliseconds(FIdleTimeOutValue)))
                                    {
                                        cnn.BeginDisconnect();
                                    }

                                }

                            }
                            finally
                            {

                                ThreadEx.LoopSleep(ref loopSleep);

                            }

                        }

                    }

                }
                finally
                {
                    
                    if (!Disposed)
                    {
                        //----- Restart the timer event!
                        FIdleTimer.Change(FIdleCheckInterval, FIdleCheckInterval);
                    }

                }

            }

        }

        #endregion

        #region Creators Methods

        #region AddCreator

        protected void AddCreator(BaseSocketConnectionCreator creator)
        {

            if (!Disposed)
            {
                lock (FSocketCreators)
                {
                    FSocketCreators.Add(creator);
                }

            }

        }

        #endregion

        #region RemoveCreator

        protected void RemoveCreator(BaseSocketConnectionCreator creator)
        {
            if (!Disposed)
            {
                lock (FSocketCreators)
                {
                    FSocketCreators.Remove(creator);

                    if (FSocketCreators.Count <= 0)
                    {
                        FWaitCreatorsDisposing.Set();
                    }

                }
            }
        }

        #endregion

        #region GetSocketCreators

        protected BaseSocketConnectionCreator[] GetSocketCreators()
        {

            BaseSocketConnectionCreator[] items = null;

            if (!Disposed)
            {
                lock (FSocketCreators)
                {
                    items = new BaseSocketConnectionCreator[FSocketCreators.Count];
                    FSocketCreators.CopyTo(items, 0);
                }

            }

            return items;

        }

        #endregion

        #endregion

        #endregion

        #region Properties

        public int SocketBufferSize
        {
            get { return FSocketBufferSize; }
            set { FSocketBufferSize = value; }  
        }

        public int MessageBufferSize
        {
            get { return FMessageBufferSize; }
            set { FMessageBufferSize = value; }  
        }

        public byte[] Delimiter
        {
            get { return FDelimiter; }
            set { FDelimiter = value; }
        }

        public DelimiterType DelimiterType
        {
            get { return FDelimiterType; }
            set { FDelimiterType = value; }
        }

        public ISocketService SocketService
        {
            get { return FSocketService; }
        }

        protected Timer CheckTimeOutTimer
        {
            get { return CheckTimeOutTimer; }
        }

        public int IdleCheckInterval
        {
            get { return FIdleCheckInterval; }
            set { FIdleCheckInterval = value; }
        }

        public int IdleTimeOutValue
        {
            get { return FIdleTimeOutValue; }
            set { FIdleTimeOutValue = value; } 
        }

        public HostType HostType
        {
            get { return FHostType; }
        }

        public bool Active
        {

            get
            {
                if (Disposed)
                {
                    return false;
                }

                lock (FSyncActive)
                {
                    return FActive;
                }
            }

            internal set
            {
                lock (FSyncActive)
                {
                    FActive = value;
                }
            }

        }


        #endregion

    }

}