socketclientsync.cs

来自「ActiveSync数据同步」· CS 代码 · 共 889 行 · 第 1/2 页

                                //----- Received!
                                lock (FReceivedQueue)
                                {

                                    if (FReceivedQueue.Count > 0)
                                    {
                                        result = FReceivedQueue.Dequeue();
                                    }

                                }

                                FLastException = null;

                                break;

                            case 1:

                                //----- Disconnected!
                                DoDisconnect();
                                break;

                            case 2:

                                //----- Exception!
                                break;

                            default:

                                //----- TimeOut!
                                FLastException = new TimeoutException("Read timeout.");
                                break;

                        }

                    }

                }

            }

            return result;

        }

        #endregion

        #region DoDisconnect

        internal void DoDisconnect()
        {

            bool fireEvent = false;
            
            lock (FConnectedSync)
            {

                if (FConnected)
                {

                    //----- Disconnect!
                    FConnected = false;
                    FSocketConnection = null;

                    if (FSocketClient != null)
                    {
                        FSocketClient.Stop();
                        FSocketClient.Dispose();
                        FSocketClient = null;
                    }
                    
                    fireEvent = true;
                    
                }

            }

            if ( (FOnDisconnectedEvent != null) && fireEvent)
            {
                FOnDisconnectedEvent();
            }

        }

        #endregion

        #region Disconnect

        public void Disconnect()
        {

            if (!Disposed)
            {

                FLastException = null;

                if (Connected)
                {

                    FExceptionEvent.Reset();

                    if (FSocketConnection != null)
                    {

                        WaitHandle[] wait = new WaitHandle[] { FDisconnectEvent, FExceptionEvent };

                        FSocketConnection.BeginDisconnect();

                        int signaled = WaitHandle.WaitAny(wait, FConnectTimeout, false);

                        switch (signaled)
                        {

                            case 0:

                                DoDisconnect();
                                break;

                            case 1:

                                //----- Exception!
                                DoDisconnect();
                                break;

                            default:

                                //----- TimeOut!
                                FLastException = new TimeoutException("Disconnect timeout.");
                                break;

                        }

                    }

                }
            }
        }

        #endregion

        #endregion

        #region Properties

        public event OnDisconnectEvent OnDisconnected
        {

                add
                {
                    FOnDisconnectedEvent += value;
                }

                remove
                {
                    FOnDisconnectedEvent -= value;
                }
        
        }

        public event OnSymmetricAuthenticateEvent OnSymmetricAuthenticate
        {

            add 
            {
                FOnSymmetricAuthenticateEvent += value;
            }

            remove 
            {
                FOnSymmetricAuthenticateEvent -= value;
            }

        }

        public event OnSSLClientAuthenticateEvent OnSSLClientAuthenticate
        {

            add
            {
                FOnSSLClientAuthenticateEvent += value;
            }

            remove
            {
                FOnSSLClientAuthenticateEvent -= value;
            }

        }
        
        public IPEndPoint RemoteEndPoint
        {
            get { return FRemoteEndPoint; }
            set { FRemoteEndPoint = value; }
        }

        public IPEndPoint LocalEndPoint
        {
            get { return FLocalEndPoint; }
            set { FLocalEndPoint = value; }
        }
        
        public DelimiterType DelimiterType
        {
            get { return FDelimiterType; }
            set { FDelimiterType = value; }
        }

        public EncryptType EncryptType
        {
            get { return FEncryptType; }
            set { FEncryptType = value; }
        }

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

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

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

        internal ManualResetEvent DisconnectEvent
        {

            get
            {
                return FDisconnectEvent;
            }

        }

        internal AutoResetEvent ConnectEvent
        {

            get
            {
                return FConnectEvent;
            }

        }

        internal AutoResetEvent SentEvent
        {

            get
            {
                return FSentEvent;
            }

        }

        internal AutoResetEvent ExceptionEvent
        {

            get
            {
                return FExceptionEvent;
            }

        }

        internal ISocketConnection SocketConnection
        {

            get
            {
                return FSocketConnection;
            }

            set 
            {
                FSocketConnection = value;
            }

        }

        public bool Connected
        {
            
            get
            {

                bool connected = false;

                lock (FConnectedSync)
                {
                    connected = FConnected;
                }

                return connected;
                
            }

            internal set 
            {

                lock (FConnectedSync)
                {
                    FConnected = value;
                }

            }

        }

        public Exception LastException
        {
            
            get
            {
                return FLastException;
            }

            internal set
            {
                FLastException = value;
            }

        }

        #endregion

    }

    #endregion

    #region SocketClientSyncSocketService
    
    internal class SocketClientSyncSocketService: BaseSocketService
    {

        #region Fields

        private SocketClientSync FSocketClient;

        #endregion

        #region Constructor

        public SocketClientSyncSocketService(SocketClientSync client)
        {
            FSocketClient = client;
        }

        #endregion

        #region Methods

        public override void OnConnected(ConnectionEventArgs e)
        {
            FSocketClient.SocketConnection = e.Connection;
            FSocketClient.SocketConnection.BeginReceive();
            FSocketClient.ConnectEvent.Set();
        }

        public override void OnException(ExceptionEventArgs e)
        {
            FSocketClient.LastException = e.Exception;
            FSocketClient.ExceptionEvent.Set();
        }

        public override void OnSent(MessageEventArgs e)
        {
            FSocketClient.SentEvent.Set();
        }

        public override void OnReceived(MessageEventArgs e)
        {
            FSocketClient.Enqueue(Encoding.GetEncoding(1252).GetString(e.Buffer));
            FSocketClient.SocketConnection.BeginReceive();
        }

        public override void OnDisconnected(ConnectionEventArgs e)
        {
            FSocketClient.DisconnectEvent.Set();
        }

        #endregion

    }

    #endregion

    #region SocketClientSyncCryptService

    internal class SocketClientSyncCryptService : BaseCryptoService
    {

        #region Fields

        private SocketClientSync FSocketClient;

        #endregion

        #region Constructor

        public SocketClientSyncCryptService(SocketClientSync client)
        {
            FSocketClient = client;
        }

        #endregion

        #region Methods

        public override void OnSymmetricAuthenticate(ISocketConnection connection, out RSACryptoServiceProvider serverKey, out byte[] signMessage)
        {
            FSocketClient.DoOnSymmetricAuthenticate(connection, out serverKey, out signMessage);
        }

        public override void OnSSLClientAuthenticate(ISocketConnection connection, out string serverName, ref X509Certificate2Collection certs, ref bool checkRevocation)
        {
            FSocketClient.DoOnSSLClientAuthenticate(connection, out serverName, ref certs, ref checkRevocation);
        }

        #endregion

    }

    #endregion

}