示例#1
0
        public void Connect()
        {
            ExchangeBalances = new Dictionary <string, double>();

            Bids = new SortedDictionary <double, BookEntry>();
            Asks = new SortedDictionary <double, BookEntry>();

            TickerData = new Dictionary <Ticker, TickerData>();
            TickerAge  = new Dictionary <Ticker, DateTime>();

            channel_ids = new Dictionary <int, string>();

            Uri endpoint_uri = new Uri(Endpoint);

            bool tls = endpoint_uri.Scheme == "wss";

            TcpClient tcp = new TcpClient(endpoint_uri.Host, tls ? 443 : 80);

            client = new ClientConnection(tcp, tls, endpoint_uri.Host);

            Log.Info("Connecting to {0}:{1}...", endpoint_uri.Host, ((IPEndPoint)tcp.Client.RemoteEndPoint).Port);

            client.OnDataReceived += (sender, msg, payload) =>
            {
                LastMessage = DateTime.Now;

                string payload_str = Encoding.UTF8.GetString(payload);

                try
                {
                    var obj = JToken.Parse(payload_str);

                    if (obj.Type == JTokenType.Array) // channel data
                    {
                        var arr = (JArray)obj; HandleChannelMessage(arr);
                        //Log.Debug("New message from channel {0}/{1}", arr[0].Value<int>(), arr[1].Value<string>());
                    }
                    else if (obj.Type == JTokenType.Object) // other data
                    {
                        HandleInfoMessage((JObject)obj);
                    }
                    else
                    {
                        Log.Warn("Unrecognized JToken type {0}", obj.Type);
                    }
                }
                catch (Exception ex)
                {
                    Log.Warn(ex);
                }
            };

            client.PerformHandshake(endpoint_uri.Host, endpoint_uri.PathAndQuery, "");
            client.StartThreads();

            LastMessage = DateTime.Now;

            Log.Info("Connected");
            OnConnect?.Invoke(this);
        }
示例#2
0
 public void handleConnect(IChannel channel)
 {
     OneThreadSynchronizationContext.Instance.Post((obj) =>
     {
         OnConnect?.Invoke((IChannel)obj);
     }, channel);
 }
示例#3
0
    public void StartListening(String host, int port, OnReceive on_receive, OnConnect on_connect, OnDisconnect on_disconnect, OnListenError on_listen_error)
    {
        on_receive_      = on_receive;
        on_connect_      = on_connect;
        on_disconnect_   = on_disconnect;
        on_listen_error_ = on_listen_error;
        size_receiving_  = 0;
        IPAddress ipAddress = IPAddress.Parse(GetIPAddress(host));

        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);

        // Create a TCP/IP socket.
        listener_ = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        listener_.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

        // Bind the socket to the local endpoint and listen for incoming connections.
        try
        {
            listener_.Bind(localEndPoint);
            listener_.Listen(0);

            // Start an asynchronous socket to listen for connections.
            listener_.BeginAccept(new AsyncCallback(AcceptCallback), listener_);
        }
        catch (Exception e)
        {
            on_listen_error_(e.ToString());
        }
    }
示例#4
0
        public async Task ReceiveAsync(int bufferSize = 1024 * 4)
        {
            OnConnect?.Invoke(this, ws.State == WebSocketState.Open);
            var buffer = new byte[bufferSize];

            try
            {
                while (true)
                {
                    var array  = new ArraySegment <byte>(buffer);
                    var result = await ws.ReceiveAsync(array, CancellationToken.None);

                    // FIXME result.CloseStatus or !result.CloseStatus
                    // if (result.MessageType == WebSocketMessageType.Close || !result.CloseStatus.HasValue)
                    if (result.MessageType == WebSocketMessageType.Close || result.CloseStatus.HasValue)
                    {
                        break;
                    }
                    var data = array.Slice(0, result.Count).ToArray();
                    OnMessageReceive?.Invoke(this, new Message {
                        Client = this, MessageType = result.MessageType, Data = data
                    });
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            Close();
        }
示例#5
0
        // http://msdn.microsoft.com/en-us/library/system.net.sockets.addressfamily.aspx
        /// <summary>
        ///     Connects to a vehicle on a supplied ip and port
        ///     Clears callback functions
        ///     Zeros out callback counter
        ///     Registers a callback for the login
        ///     This starts a thread for received data.
        /// </summary>
        /// <param name="vehicleIpEndPoint">Socket for vehicle</param>
        /// <param name="login">Login information</param>
        public void Connect(Broadcast bcast, Login login)
        {
            if (Socket != null)
            {
                throw new ConnectionException("Device already controlled/connected to a client.");
            }

            Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                Socket.Connect(bcast.Endpoint);
            }
            catch (SocketException ex)
            {
                throw new ConnectionException("Could not connect to vehicle.", ex);
            }

            if (!Socket.Connected)
            {
                Socket = null;
                throw new ConnectionException("Could not connect to vehicle.");
            }

            _callbacks.Clear();

            OnConnect?.Invoke(bcast);

            _thread.Start();

            Login(login);
        }
示例#6
0
        public bool InitDeviceAuto()
        {
            _log.TraceInfo("Beginning AUTO initialization...");
            string order = "";

            foreach (int item in _xattr)
            {
                order += "," + item.ToString();
            }
            order = order.TrimStart(',');
            _log.TraceInfo("Auto Protocol Order: " + order);
            _log.TraceInfo("Application Layer Protocol: " + STDType.ToString());

            SetDevice(HardwareType.ELM327);
            bool flag;

            DllSettings.StandardIndex = STDType;
            flag    = _obdDevice.InitializeAuto(DllSettings);
            STDType = _obdDevice.GetStandardType();
            if (flag)
            {
                DllSettings.ProtocolIndex = _obdDevice.GetProtocolType();
                DllSettings.ComPort       = _obdDevice.GetComPortIndex();
                SaveDllSettings(DllSettings);
                OnConnect?.Invoke();
                return(true);
            }
            return(false);
        }
        /// <summary>
        /// 处理客户端连接请求
        /// </summary>
        /// <param name="result"></param>
        private void Accept(IAsyncResult socket)
        {
            // 还原传入的原始套接字
            Socket SockeServer = (Socket)socket.AsyncState;
            // 在原始套接字上调用EndAccept方法,返回新的套接字
            Socket SockeClient = SockeServer.EndAccept(socket);

            byte[] buffer = new byte[4096];
            try
            {
                //接收客户端的数据
                SockeClient.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(HandShake), SockeClient);

                //保存登录的客户端
                Session session = new Session(buffer, SockeClient);
                lock (SessionPool)
                {
                    if (SessionPool.ContainsKey(session.IP))
                    {
                        this.SessionPool.Remove(session.IP);
                    }
                    this.SessionPool.Add(session.IP, session);
                }
                //准备接受下一个客户端
                SockeServer.BeginAccept(new AsyncCallback(Accept), SockeServer);
                OnConnect?.Invoke(this, new ClientConnectEventArgs(session));
                Console.WriteLine(string.Format("WebSocketServer:Client {0} connected", SockeClient.RemoteEndPoint));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error : " + ex.ToString());
            }
        }
示例#8
0
        private void ConnectCandidate()
        {
            if (_nearJointPoint == null || _senderJointPoint == null)
            {
                return;
            }

            if (_nearJointPoint.JointBehaviour._rigidbody.isKinematic != _senderJointPoint.JointBehaviour._rigidbody.isKinematic)
            {
                Debug.Log($"Can not connect joints with different kinematics");
                return;
            }

            Debug.Log($"Joint invoke! {_senderJointPoint}");
            TransformToJoint(_nearJointPoint.JointBehaviour.gameObject, _nearJointPoint, _senderJointPoint);
            _senderJointPoint.Connect(_nearJointPoint.JointBehaviour.gameObject, _nearJointPoint);

            if (AutoLock)
            {
                _senderJointPoint.Lock();
            }

            OnConnect?.Invoke();
            _nearJointPoint.JointBehaviour.OnConnect?.Invoke();
        }
示例#9
0
        private void ConnectInternal()
        {
            try
            {
                //start keepAlive timer only on first connect
                if (_reconnectTimer == null)
                {
                    _reconnectTimer          = new System.Timers.Timer(_settings.ReconnectInterval * 1000);
                    _reconnectTimer.Elapsed += ReconnectTimer_Elapsed;;
                    _reconnectTimer.Start();
                }

                if (_isInConnectInternal)
                {
                    return;
                }
                _isInConnectInternal = true;

                if (_socket != null)
                {
                    try { _socket.Dispose(); } catch { }
                    _socket = null;
                }

                foreach (var serverAddress in _settings.ServerAddressList)
                {
                    try
                    {
                        _socket = TcpSocketsUtils.Connect(serverAddress.Item1, serverAddress.Item2);
                        break;
                    }
                    catch
                    {
                        OnDebugLog?.Invoke(DebugLogType.ConnectFailed, $" host:{serverAddress.Item1} port:{serverAddress.Item2} ");
                    }
                }
                _connectEvent.Set();


                if (_socket != null)
                {
                    IsConnected = true;
                    OnConnect?.Invoke();
                    TcpSocketsUtils.Recv(
                        _socket,
                        OnRecv,
                        OnExcp,
                        OnRecvProgress,
                        _settings.ReceiveBufferSize == 0 ? TcpSocketsUtils.ms_DefualtReceiveBufferSize : _settings.ReceiveBufferSize,
                        true);
                }
            }
            catch (Exception ex)
            {
            }
            finally
            {
                _isInConnectInternal = false;
            }
        }
示例#10
0
 private async void NewClient(Socket socket, int millisecondsDelay)
 {
     try
     {
         socket.Connect(address);
         OnConnect?.Invoke(this, new EventArgs());
     }
     catch (Exception exception)
     {
         OnConnectException?.Invoke(this, new ExceptionEventArgs(socket, exception));
     }
     while (true)
     {
         try
         {
             socket.Send(messageBuffer);
             OnSend?.Invoke(this, new EventArgs());
         }
         catch (Exception exception)
         {
             OnSendException?.Invoke(this, new ExceptionEventArgs(socket, exception));
         }
         await Task.Delay(millisecondsDelay);
     }
 }
示例#11
0
        public async void Connect()
        {
            Logger.Debug("Signaling", "Connect");

            if (closed)
            {
                Logger.Debug("Signaling", "already closed");
                return;
            }

            try
            {
                await socket.ConnectAsync(new Uri($"{endpoint}?channel_id={channelId}"));

                socketWriter = new DataWriter(socket.OutputStream);

                OnConnect?.Invoke();

                await SendConnectMessage();
            }
            catch (Exception ex)
            {
                Logger.Debug("Signaling", $"failed to connect websocket: {ex.Message}");
                OnError?.Invoke(ErrorType.SocketCantConnect);
            }
        }
        /// <summary>
        /// Handles connection info response from PlayFab (called on Connect) and starts the connection to the hub.
        /// </summary>
        /// <param name="connectionInfo"></param>
        private async void OnConnectionInfoSuccess(GetConnectionInfoResponse connectionInfo)
        {
            _accessToken = connectionInfo.AccessToken;
            _uri         = connectionInfo.Url;
            CreateHubConnection();
            try
            {
                if (Debugging)
                {
                    Debug.Log("Trying to connect to hub");
                }
                await _hubConnection.StartAsync();

                if (Debugging)
                {
                    Debug.Log("Connected To Hub");
                }
                OnConnect?.Invoke();
            }
            catch (Exception ex)
            {
                OnConnectionError?.Invoke(new PlayFabError()
                {
                    Error        = PlayFabErrorCode.InternalServerError,
                    ErrorMessage =
                        string.Format("PersistentSocket failed to start the connection with the message: {0}",
                                      !string.IsNullOrEmpty(ex.Message) ? ex.Message : string.Empty)
                });
            }
        }
示例#13
0
        private void onConnStateChange(object sender, StateChangeEventArgs e)
        {
            if (e.CurrentState == ConnectionState.Open)
            {
                _connected = true;
                backlogTimer.Start();

                OnConnect?.Invoke(this, EventArgs.Empty);
                sendNext();
            }
            else if (e.CurrentState == ConnectionState.Closed || e.CurrentState == ConnectionState.Broken)
            {
                backlogTimer.Stop();

                string oldDbString = dbString;
                dbString = null;

                conn    = null;
                command = null;
                backlog.Clear();
                _connected = false;
                _busy      = false;

                OnDisconnect?.Invoke(this, EventArgs.Empty);
            }
        }
        public async Task Connect()
        {
            if (Client == null)
            {
                throw new NotActiveException();
            }

            if (Client.IsConnecting || Client.IsConnected)
            {
                return;
            }

            try
            {
                Client.Connect();

                await Task.Run(() =>
                {
                    // Await connectiong
                    while (Client.IsConnecting || MainActivity.Activity.AuthInProgress)
                    {
                        Task.Delay(50);
                    }
                });

                if (Client.IsConnected)
                {
                    OnConnect?.Invoke();
                }
            }
            catch (Exception e)
            {
                OnError?.Invoke(e.Message);
            }
        }
示例#15
0
        public void Service(uint timeout)
        {
            while (Service(out ENetEvent e, timeout))
            {
                if (e is ENetNoneEventArgs)
                {
                    continue;
                }

                if (e is ENetConnectEventArgs connect)
                {
                    OnConnect?.Invoke(this, connect);
                    continue;
                }

                if (e is ENetDisconnectEventArgs disconnect)
                {
                    disconnect.Peer.RaiseDisconnectEvent(disconnect.Data);
                    continue;
                }

                if (e is ENetReceiveEventArgs receive)
                {
                    receive.Peer.RaiseReceiveEvent(receive.Packet);
                    continue;
                }
            }
        }
示例#16
0
 public void Connect()
 {
     ConnectionFailed = false;
     Task.Run(() => {
         try
         {
             if (Ip == null)
             {
                 return;
             }
             OnConnecting?.Invoke(this, null);
             client?.Dispose();
             client = new TcpClient(Ip.ToString(), Port)
             {
                 NoDelay = true
             };
             nwStream = client.GetStream();
             if (TurnOnWhenConnected)
             {
                 Turn(true);
             }
             OnConnect?.Invoke(this, null);
         }
         catch (Exception)
         {
             ConnectionFailed = true;
             OnConnectFail?.Invoke(this, null);
         }
     });
 }
示例#17
0
 private void AsyncInit(TcpListener tcpListener, string hostName, int port)
 {
     while (!disposed)
     {
         var accept = tcpListener.AcceptTcpClientAsync();
         if (accept.Wait(1000, tokenSource.Token) && !tokenSource.IsCancellationRequested)
         {
             var localClient = accept.GetAwaiter().GetResult();
             OnConnect?.Invoke(this, new ProxyConnectionEventArgs(localClient));
             var remoteClient = new TcpClient()
             {
                 NoDelay = true
             };
             tokenSource.Token.Register(() =>
             {
                 localClient.Dispose();
                 remoteClient.Dispose();
             });
             remoteClient.ConnectAsync(hostName, port).Wait(tokenSource.Token);
             if (!tokenSource.IsCancellationRequested)
             {
                 Task.Factory.StartNew(() => { ForwardToSql(localClient, remoteClient); });
                 Task.Factory.StartNew(() => { ForwardToClient(localClient, remoteClient); });
             }
             else
             {
                 Trace.TraceInformation("AsyncInit aborted due to cancellation token set");
             }
         }
     }
 }
示例#18
0
 public Host(int port)
 {
     EnableHandshake = true;
     AllowedTokens   = AllowedTokens.Any;
     //ValidateMessageTypes();
     _listenThread      = new Thread(() => Listen(port));
     _port              = port;
     _isListening       = false;
     _connectionManager = new ConnectionManager();
     _receiveHandlers   = new Dictionary <short, IList <ReceiveHandler> >();
     Rnd = new Random();
     AddHandler((short)MessageType.Token, (m, c) => {
         _hostToken = m.ConnectionToken;
         if (OnConnect != null)
         {
             OnConnect.Invoke();
         }
     });
     AddHandler((short)MessageType.Handshake, (m, c) => {
         if (!EnableHandshake)
         {
             return;
         }
         if (ConnectionCreated != null)
         {
             ConnectionCreated.Invoke(c);
         }
         SendToken(c);
     });
     AddHandler((short)MessageType.Ack, (m, c) => { c.ProcessAck(m); });
     ServerTimer.OnTick += ServerTick;
 }
        private async Task HandleWebSocketAsync(WebSocket websocket)
        {
            try
            {
                OnConnect?.Invoke(websocket);

                while (websocket.IsConnected)
                {
                    var message = await websocket.ReadStringAsync(CancellationToken.None)
                                  .ConfigureAwait(false);

                    if (message != null)
                    {
                        OnMessage?.Invoke(websocket, message);
                    }
                }

                OnDisconnect?.Invoke(websocket);
            }
            catch (Exception ex)
            {
                OnError?.Invoke(websocket, ex);
            }
            finally
            {
                websocket.Dispose();
            }
        }
示例#20
0
        public new bool Connect(string ip, int port)
        {
            if (IsConnected)
            {
                return(true);
            }

            mServerAdress = new IPEndPoint(IPAddress.Parse(ip), port);

            Connect(mServerAdress);

            if (IsConnected == false)
            {
                Close();
                return(false);
            }

            mReceiveThread = new Thread(ReceiveThread);
            mSendThread    = new Thread(SendThread);
            mReceiveThread.Start();
            mSendThread.Start();

            OnConnect?.Invoke();
            return(true);
        }
示例#21
0
 public bool BeginConnect(IPEndPoint ep, Token token)
 {
     _hostToken = token;
     _connectionManager.Add(token, new Connection(ep));
     OnConnect.Invoke();
     return(true);
 }
示例#22
0
 public CommServer()
 {
     server           = new TcpPackServer();
     queue            = new BlockingCollection <IMsg>();
     server.OnAccept += delegate(IServer sender, IntPtr connId, IntPtr client)
     {
         OnConnect?.Invoke();
         return(HandleResult.Ok);
     };
     server.OnReceive += delegate(IServer sender, IntPtr connId, byte[] bytes)
     {
         Message message = new Message();
         message.MergeFrom(bytes);
         try
         {
             queue.Add(message);//理论上这里可能抛出异常ObjectDisposedException或InvalidOperationException
         }
         catch (Exception e)
         {
             Console.WriteLine("Exception occured when adding an item to the queue:" + e.Message);
         }
         OnReceive?.Invoke();
         return(HandleResult.Ok);
     };
 }
示例#23
0
        public void Start()
        {
            // Only start once
            if (Started)
            {
                return;
            }
            Started = true;
            Client.Connect(IPAddress.Loopback, Constants.ClientConnectionPort);
            OnConnect?.Invoke(this, new IDEventArgs(ID));

            byte[] IDData = Encoding.UTF8.GetBytes(ID.ToString() + Environment.NewLine);
            Client.GetStream().Write(IDData, 0, IDData.Length);

            Worker = new Thread(new ThreadStart(async() =>
            {
                using (StreamReader Reader = new StreamReader(Client.GetStream(), Encoding.UTF8))
                {
                    do
                    {
                        if (ShouldStop)
                        {
                            break;
                        }
                        else
                        {
                            Thread.Sleep(Constants.WorkerDelay);
                        }
                        string Line = await Reader.ReadLineAsync();
                        OnMessage?.Invoke(this, new MessageEventArgs(ID, Line));
                    } while (!ShouldStop);
                }
            }));
            Worker.Start();
        }
示例#24
0
        public void StartListening(String host, int port, OnConnect on_connect, OnDisconnect on_disconnect)
        {
            on_connect_     = on_connect;
            on_disconnect_  = on_disconnect;
            size_receiving_ = 0;
            lock_           = new object();
            queue_          = new Deque <byte>(1000000);
            IPAddress ipAddress = IPAddress.Parse(GetIPAddress(host));

            IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);

            // Create a TCP/IP socket.
            listener_ = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            // Bind the socket to the local endpoint and listen for incoming connections.
            try
            {
                listener_.Bind(localEndPoint);
                listener_.Listen(0);

                // Start an asynchronous socket to listen for connections.
                listener_.BeginAccept(new AsyncCallback(AcceptCallback), listener_);
            }
            catch (Exception e)
            {
                on_disconnect_(e.ToString());
            }
        }
示例#25
0
        private static async void Connect()
        {
            var client = new Client();

            client.Handler = HandleSignal;

            await client.Initialize(Config.UserId.ToString());

            var retry      = 0;
            var resetTimer = new Timer(10000);

            resetTimer.Elapsed += (s, e) => retry = 0;

            IsRunning = true;
            OnConnect?.Invoke();
            while (!await client.Start() && retry < 3)
            {
                if (retry > 0)
                {
                    resetTimer.Stop();
                }
                retry++;
                resetTimer.Start();
            }
            IsRunning = false;
            OnExit?.Invoke();
        }
示例#26
0
        private void timeoutHandler()
        {
            // TODO:  differentiate between a loss of connection and commands that just aren't responded too
            System.Diagnostics.Debugger.Break();

            bool connected = deviceCommDriver.IsOpen();

            // if the connection fails, log a message to the console and keep retrying for 1 minute
            if (!connected)
            {
                MainPage.ShowText("Connection failed.  Retrying...");
                deviceCommDriver.Close();

                DateTime dtStart  = DateTime.Now;
                DateTime dtStopAt = dtStart.AddSeconds(retrySeconds);
                while (DateTime.Now < dtStopAt && !connected)
                {
                    System.Diagnostics.Debugger.Break();
                    Thread.Sleep(500);
                    deviceCommDriver.BtConnect(deviceId).ConfigureAwait(false);
                }
            }

            if (connected)
            {
                OnConnect.Invoke(this);
            }
            else
            {
                System.Diagnostics.Debugger.Break();
            }
        }
示例#27
0
 public ConnectStage(Regulus.Remoting.Ghost.TProvider<Project.SamebestKeys.IConnect> connect_provider, OnConnect connect)
 {
     // TODO: Complete member initialization
     this._ConnectProvider = connect_provider;
     _Connect = connect;
     _Connecter = new Connect();
 }
        /// <summary>
        /// Start listening for incoming connections
        /// </summary>
        private void StartServer()
        {
            InitializeSocket();
            // Create a task that will run and search for connections
            Task.Run(() =>
            {
                if (handler == null && IsClient == false)
                {
                    try
                    {
                        handler = new ConnectionHandler(Socket.Accept());

                        handler.MessageReceived += ReceiveData;

                        handler.OnDisconnect += ClientDisconnected;

                        System.Diagnostics.Debug.WriteLine("Triggering client connect");
                        OnConnect?.Invoke(this, new SocketEventArgs(handler.Socket));
                    }
                    catch
                    {
                        Close();
                    }
                }
            });
        }
示例#29
0
 public static void FireOnConnect()
 {
     if (OnConnect != null)
     {
         OnConnect.Invoke();
     }
 }
        public async Task ReceiveAsync(int bufferSize = 1024 * 4)
        {
            OnConnect?.Invoke(this, ws.State == WebSocketState.Open);

            try
            {
                while (true)
                {
                    var buffer = new byte[bufferSize];
                    var result = await ws.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);

                    if (result.MessageType == WebSocketMessageType.Close ||
                        !result.CloseStatus.HasValue)
                    {
                        break;
                    }

                    OnMessageReceive?.Invoke(this, new Message {
                        Client = this, MessageType = result.MessageType, Data = buffer
                    });
                }
            }
            catch { }

            Close();
        }
示例#31
0
        private async Task EventLoop()
        {
            var token = _eventLoopCancellation.Token;

            var buffer       = new byte[RECEIVE_CHUNK_SIZE];
            var segment      = new ArraySegment <byte>(buffer);
            var memoryStream = new MemoryStream();

            // Connect socket.
            await _socket.ConnectAsync(_uri, token);

            // Run event loop.
            try
            {
                await(OnConnect?.Invoke() ?? Task.CompletedTask);

                // Receive messages.
                while (WebSocketState.Open == _socket.State)
                {
                    WebSocketReceiveResult received;
                    do
                    {
                        received = await _socket.ReceiveAsync(segment, token);

                        memoryStream.Write(buffer, 0, received.Count); // Don't use async, memoryStream doesn't do IO.
                    }while (!received.EndOfMessage);

                    // Trigger event. ToArray makes copy of buffer.
                    await(OnMessage?.Invoke(memoryStream.ToArray()) ?? Task.CompletedTask);

                    // Reset memoryStream (also sets the position to zero).
                    memoryStream.SetLength(0);
                }
            }
            finally
            {
                // Trigger OnDisconnect.
                try
                {
                    await(OnDisconnect?.Invoke() ?? Task.CompletedTask);
                }
                finally
                {
                    // Close Socket.
                    try
                    {
                        await _socket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, token);
                    }
                    catch
                    {
                        _socket.Abort();
                    }
                    finally
                    {
                        _socket.Dispose();
                    }
                }
            }
        }
示例#32
0
        public void Connect(byte chServerType, String m_serverIP, int m_serverPort, OnConnect dlg = null)
        {
            Guid m_Version = new Guid ("{0x5f6f921f,0x285f,0x40dc,{0x8f,0xd3,0xcf,0x5a,0xb3,0x84,0x80,0x66}}");

            NetConnectionParam cp = new NetConnectionParam ();
            cp.protocolVersion = m_Version;
            cp.serverIP = m_serverIP;
            cp.serverPort = (ushort)m_serverPort;

            #if UNITY_WEBPLAYER
            Security.PrefetchSocketPolicy(m_serverIP, m_serverPort);
            #endif
            if(dlg != null) {
                ConnectHandler = dlg;
            }
            if (m_Client.Connect (cp) == false) {
                if (dlg != null)
                {
                    dlg(false);
                }
            }
        }
示例#33
0
文件: Sdk.cs 项目: yxdh/HP-Socket
 public static extern void HP_Set_FN_Client_OnConnect(IntPtr pListener, OnConnect fn);
示例#34
0
        IEnumerator<ITask> OnConnectHandler(OnConnect onConnect)
        {
            if (onConnect.DriveControl == _driveControl)
            {
                UriBuilder builder = new UriBuilder(onConnect.Service);
                builder.Scheme = new Uri(ServiceInfo.Service).Scheme;

                ds.DirectoryPort port = ServiceForwarder<ds.DirectoryPort>(builder.Uri);
                // TT Nov-2006 - Changed for new CTP
                // ds.Get get = new ds.Get(GetRequestType.Instance);
                ds.Get get = new ds.Get();

                port.Post(get);
                ServiceInfoType[] list = null;

                yield return Arbiter.Choice(get.ResponsePort,
                    delegate(ds.GetResponseType response)
                    {
                        list = response.RecordList;
                    },
                    delegate(Fault fault)
                    {
                        list = new ServiceInfoType[0];
                        LogError(fault);
                    }
                );

                WinFormsServicePort.FormInvoke(
                    delegate()
                    {
                        _driveControl.ReplaceDirectoryList(list);
                    }
                );
            }
        }