//Reads incoming data from client, based on length of data we got earlier //Keeps reading until it gets exact amount of bytes we need private void ReceiveMessage(int size) { try { int total = 0; byte[] buffer = new byte[size]; do { IAsyncResult result = ClientReader.BeginReceive(buffer, total, size, SocketFlags.None, null, null); result.AsyncWaitHandle.WaitOne(ClientReader.ReceiveTimeout); int received = ClientReader.EndReceive(result); total += received; if (received == 0) { break; } } while (total < size); OnReceived?.Invoke(buffer, size); } catch { OnDisconnected?.Invoke(ClientReader); } }
public ChunkRequest(Vector3 worldPos, float voxelSize, OnReceived callback, LastCheck lastCheck) { this.worldPos = worldPos; this.voxelSize = voxelSize; this.callback = callback; this.lastCheck = lastCheck; }
protected virtual void OnSend(RXSendMessage sendMsg) { var maybeReadRequest = AttributeReadRequest.DecodeFromByteArray(sendMsg.Bytes); AttributeReadResult readResult = new AttributeReadResult { ReadState = AttributeReadState.Error }; if (Attributes.ContainsKey(maybeReadRequest.RequestKey)) { var value = Attributes[maybeReadRequest.RequestKey]; readResult = new AttributeReadResult { RequestGuid = maybeReadRequest.RequestGuid, ReadState = AttributeReadState.Successful, Value = value }; } else { readResult = new AttributeReadResult { RequestGuid = maybeReadRequest.RequestGuid, ReadState = AttributeReadState.NonExsited }; } RXReceiveMessage receiveMessage = new RXReceiveMessage { RXConnection = this, Bytes = readResult.EncodeToBytesArray() }; OnReceived?.Invoke(this, receiveMessage); }
public bool Connect(IPEndPoint endPoint) { if (!active) { try { this.client = new TcpClient(); this.client.Connect(endPoint); NetworkStream networkStream = this.client.GetStream(); this.networkConnection = new NetworkConnection(ref networkStream, (IPEndPoint)client.Client.RemoteEndPoint); this.networkConnection.OnSuccessfulConnection += (x, y) => OnClientConnected?.Invoke(x, y); this.networkConnection.OnError += (x, y) => OnError?.Invoke(x, y); this.networkConnection.OnReceived += (x, y) => OnReceived?.Invoke(x, y); this.networkConnection.OnDisconnected += (x, y) => OnClientDisconnected?.Invoke(x, y); this.active = true; } catch (Exception e) { OnError?.Invoke(networkConnection, e); } finally { if (!active) { this.networkConnection?.Shutdown(); this.client?.Close(); this.networkConnection = null; this.client = null; } } } return(active); }
public void OnDataReceive(string msg) { if (OnReceived != null) { OnReceived.Invoke(msg); } }
public static void Enqueue(Vector3 worldPos, float voxelSize, OnReceived callback, LastCheck lastCheck, float priority, int id = -1) { ChunkRequest cr = new ChunkRequest(worldPos, voxelSize, callback, lastCheck); cr.id = id; queue.Enqueue(cr, priority); }
private Task _ReadInputStreamTaskAsync() { return(Task.Run(() => { var inputStream = RfcommConnection.InputStream; bool disconnected = false; while (true) { byte[] buffer = new byte[255]; var readSize = inputStream.Read(buffer, 0, buffer.Length); if (readSize == 0) { disconnected = true; break; } var readBytes = new byte[readSize]; Array.Copy(buffer, 0, readBytes, 0, readSize); var msg = new RXReceiveMessage { RXConnection = this, Bytes = readBytes }; OnReceived?.Invoke(this, msg); } if (disconnected) { RfcommConnection.Dispose(); ConnectionState = RXConnectionState.Destoryed; OnConnectionStateChanged?.Invoke(this, ConnectionState); } })); }
/// <summary> /// 接收消息 /// </summary> /// <param name="clientSocket"></param> private void ReceiveMessage(object clientSocket) { Socket myClientSocket = (Socket)clientSocket; while (true) { try { //通过clientSocket接收数据 int receiveNumber = myClientSocket.Receive(result); OnReceived?.Invoke(this, new ReceiveMessageData() { Message = Encoding.ASCII.GetString(result, 0, receiveNumber) }); //Console.WriteLine("接收客户端{0}消息{1}", myClientSocket.RemoteEndPoint.ToString(), Encoding.ASCII.GetString(result, 0, receiveNumber)); } catch (Exception ex) { //Log.OutputBox(ex); //Console.WriteLine(ex.Message); myClientSocket.Shutdown(SocketShutdown.Both); myClientSocket.Close(); break; } } }
private void ReadCallbackUDP(IAsyncResult ar) { try { if (!Socket.Connected) { return; } int readBytes = Socket.EndReceive(ar); if (readBytes > 0) { byte[] data = new byte[readBytes]; Array.Copy(Buffer, data, readBytes); OnReceived?.Invoke(this, new SocketClientEventArgs() { Data = data }); } Socket.BeginReceive(Buffer, 0, BufferSize, 0, new AsyncCallback(ReadCallbackUDP), null); } catch (SocketException se) { OnError?.Invoke(this, new ErrorEventArgs(se)); } }
public void ReadCallback(IAsyncResult ar) { log.add_to_log(log_vrste.info, "EndRead", "AsyncTCPClient.cs ReadCallback()"); Connection connection = (Connection)ar.AsyncState; int bytesRead = connection.socket.EndReceive(ar); IOStatus status; List <Message> messages = io.EndRead(connection, bytesRead, out status); if (messages.Count > 0) { /*connection.socket.BeginReceive(connection.bytes_read, 0, Connection.RBUFFER_SIZE, SocketFlags.None, * new AsyncCallback(ReadCallback), connection);*/ /*if (status == IOStatus.INCOMPLETE) * { * connection.socket.BeginReceive(connection.bytes_read, 0, Connection.RBUFFER_SIZE, SocketFlags.None, * new AsyncCallback(ReadCallback), connection); * }*/ ReceivedEventArgs args = new ReceivedEventArgs(connection.uid, messages.ToArray()); OnReceived?.Invoke(this, args); } // //{ log.add_to_log(log_vrste.info, "BeginReceive", "AsyncTCPClient.cs ReadCallback()"); connection.socket.BeginReceive(connection.tmp_rbuffer, 0, Connection.RBUFFER_SIZE, SocketFlags.None, new AsyncCallback(ReadCallback), connection); //} }
private void ProcessReceive(object sender, SocketAsyncEventArgs eventArgs) { if (eventArgs.SocketError != SocketError.Success) { Console.Error.WriteLine($"Error {eventArgs.SocketError.ToString()}"); } OnConnected?.Invoke(ProtocolType.Udp, eventArgs.RemoteEndPoint, eventArgs); if (eventArgs.BytesTransferred == 0) { OnClosed?.Invoke(ProtocolType.Udp, eventArgs.RemoteEndPoint, eventArgs); eventArgs.Dispose(); return; } (var transport, var transportMessage) = ((UdpHostTransport, TransportMessage))eventArgs.UserToken; transportMessage.UpdateBytesReceived(); // For now, UDP messages cannot extend across a single message OnReceived?.Invoke(ProtocolType.Udp, eventArgs.RemoteEndPoint, transportMessage); transportMessage.Reset(UdpPacketSize); _autoResetEvent.Set(); }
public void Receive(Message message) { _history.Add(message); // YOUR CODE GOES HERE OnReceived?.Invoke(message); }
private void ProcessReceive(object sender, SocketAsyncEventArgs eventArgs) { if (eventArgs.SocketError != SocketError.Success) { Console.Error.WriteLine($"Error {eventArgs.SocketError.ToString()}"); } (var transport, var transportMessage) = ((TcpClientTransport, TransportMessage))eventArgs.UserToken; if (eventArgs.BytesTransferred == 0) { OnClosed?.Invoke(ProtocolType.Tcp, _remoteEndPoint, eventArgs); eventArgs.Dispose(); return; } transportMessage.UpdateBytesReceived(); // Check if we're done if (transportMessage.IsReady) { OnReceived?.Invoke(ProtocolType.Tcp, _remoteEndPoint, transportMessage); transportMessage.Reset(); } StartReceivingAsync(eventArgs); }
private void ReceivedEvent(string data) { if (OnReceived == null) { return; } OnReceived.Invoke(data); }
internal override void DataProcessingCenter(AppSession session, int protocol, int customer, byte[] content) { if (protocol == InsideProtocol.ProtocolUserString) { action?.Invoke(this, Encoding.Unicode.GetString(content)); OnReceived?.Invoke(this, Encoding.Unicode.GetString(content)); } }
private async Task ReadCallback() { while (ContinueReading) { var received = cryptographicFunction.Decrypt(await Read().ConfigureAwait(false), Key); OnReceived?.Invoke(JsonSerializer.Deserialize <BaseMessage>(received)); } }
private void Run() { while (alive) { try { lock (clientList) { int index = 0; while (index < clientList.Count) { if (!IsConnected(clientList[index])) { if (OnDisconnected != null) { OnDisconnected.Invoke(clientList[index].Client.LocalEndPoint, clientList[index].Client.RemoteEndPoint); } clientList.RemoveAt(index); } else { index++; } } foreach (TcpClient client in clientList) { NetworkStream stream = client.GetStream(); if (stream != null) { byte[][] commands = ReceiveBytes(stream); if (OnReceived != null) { foreach (byte[] command in commands) { byte[] response = OnReceived.Invoke(command); if (response != null && response.Length > 0) { SendBytes(stream, response, terminator); } } } } } } } catch (Exception ex) { #if DEBUG Console.WriteLine(ex); #endif } finally { Thread.Sleep(interval); } } }
/// <summary> /// Will fire all events according to the queued messages /// </summary> public void Work() { if (Stopped) { throw new InvalidOperationException($"{nameof(EasySocket)} was stopped"); } SocketAsyncEventArgs result; while (!_acceptedSockets.IsEmpty) { if (_acceptedSockets.TryDequeue(out result)) { OnAccepted?.Invoke(Socket, result); } } while (!_receivedData.IsEmpty) { if (_receivedData.TryDequeue(out result)) { OnReceived?.Invoke(Socket, result); } } while (!_receivedFromData.IsEmpty) { if (_receivedFromData.TryDequeue(out result)) { OnReceivedFrom?.Invoke(Socket, result); } } while (!_receivedMessageFromData.IsEmpty) { if (_receivedMessageFromData.TryDequeue(out result)) { OnReceivedMessageFrom?.Invoke(Socket, result); } } while (!_sendComplete.IsEmpty) { if (_sendComplete.TryDequeue(out result)) { OnSent?.Invoke(Socket, result); } } while (!_sendToComplete.IsEmpty) { if (_sendToComplete.TryDequeue(out result)) { OnSentTo?.Invoke(Socket, result); } } }
public TransportManager(IEnumerable <IClientTransport> transports) { foreach (var transport in transports) { _transports[transport.ProtocolType] = transport; transport.OnConnected += (p, e, saea) => (OnConnected?.Invoke(p, e, saea) ?? Task.CompletedTask); transport.OnReceived += (p, e, m) => (OnReceived?.Invoke(p, e, m) ?? Task.CompletedTask); transport.OnClosed += (p, e, saea) => (OnClosed?.Invoke(p, e, saea) ?? Task.CompletedTask); } }
void DataReceived(SDDataReceivedEventArgs args) { OnReceived?.Invoke(args); if (lastSent < Time.time) { OnProgress?.Invoke(args); lastSent = Time.time + 0.1f; CalculateAvrage(); } }
void StartReceive() { try { int bufLen = 1024; byte[] buffer = new byte[bufLen]; NetworkStream stream = _client.GetStream(); while (_isRunning && !_disposing) { //while (stream.DataAvailable) //{ int readBytes = stream.Read(buffer, 0, bufLen); if (readBytes > 0) { //string msg = Encoding.UTF8.GetString(buffer, 0, readBytes); string msg = Encoding.GetEncoding("gbk").GetString(buffer, 0, readBytes); OnReceived?.Invoke(this, msg); } else { FireClosed(); } //} Thread.Sleep(5); } } catch (IOException) { FireClosed(); } catch (ArgumentOutOfRangeException) { if (!_disposing) { LogHelper.Write("LXTcpConnection", "ArgumentOutOfRangeException"); } } catch (ObjectDisposedException) { if (!_disposing) { LogHelper.Write("LXTcpConnection", "ObjectDisposedException"); } FireClosed(); } catch (InvalidOperationException) { if (!_disposing) { LogHelper.Write("LXTcpConnection", "InvalidOperationException"); } FireClosed(); } catch (Exception ex) { LogHelper.Write("LXTcpConnection", ex); } }
private void RaiseOnReceive(DataReceivedArgs args) { try { //var data = args.Data; OnReceived?.Invoke(args); } catch (Exception) { } }
public Task <OperateResult> SendAsync(TransportMessage message) { var typeName = message.Headers["DotNetType"]; var streamId = message.Headers["StreamId"]; var type = Type.GetType(typeName); var json = Encoding.UTF8.GetString(message.Body); var evt = JsonConvert.DeserializeObject(json, type); OnReceived?.Invoke(new CapMessage(streamId, evt)); return(Task.FromResult(OperateResult.Success)); }
/// <summary> /// WebSocket監聽主程序 /// </summary> /// <param name="context">Http通訊內容</param> /// <param name="socket">WebSocket物件</param> protected async Task Listen(HttpContext context, WebSocket socket) { OnConnected?.Invoke(context, socket); Exception exception = null; //監聽迴圈 while (socket.State == WebSocketState.Open) { List <byte> receiveData = new List <byte>(); WebSocketReceiveResult receiveResult = null; //分段存取迴圈 do { //緩衝區 ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[BufferSize]); try { //接收資料 receiveResult = await socket.ReceiveAsync(buffer, CancellationToken.None); } catch (Exception e) { exception = e; break; } byte[] rawData = buffer.Array.Take(receiveResult.Count).ToArray(); OnReceiving?.Invoke( socket, receiveResult.MessageType, rawData, receiveResult.EndOfMessage); receiveData.AddRange(rawData); } while (!receiveResult.EndOfMessage); OnReceived?.Invoke(socket, receiveResult.MessageType, receiveData.ToArray()); //檢查是否關閉連線,如關閉則跳脫循環監聽 if (exception != null || receiveResult.CloseStatus.HasValue || socket.State != WebSocketState.Open) { break; } } if (exception != null) { OnException?.Invoke(socket, exception); } OnDisconnected?.Invoke(context, socket); }
private void serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e) { byte[] data = new byte[serialPort.BytesToRead]; serialPort.Read(data, 0, data.Length); // Encoding enc = Encoding.GetEncoding(1251); //String buffer = enc.GetString(data); OnReceivedEventArgs args = new OnReceivedEventArgs(data); OnReceived.Invoke(this, args); }
private void _server_OnReceive(object userToken, byte[] data) { var ut = (IUserToken)userToken; var up = (MyUnpacker)ut.Unpacker; up.Unpack(data, (package) => { OnReceived?.Invoke(package); _server.SendAsync(ut.ID, up.Process(package)); }); }
private void doChat() { NetworkStream stream = null; try { byte[] buffer = new byte[1024]; string msg = string.Empty; int bytes = 0; int MessageCount = 0; while (true) { MessageCount++; stream = clientSocket.GetStream(); bytes = stream.Read(buffer, 0, buffer.Length); JObject json = JObject.Parse(Encoding.Default.GetString(buffer, 0, bytes)); OnReceived?.Invoke(json); } } catch (SocketException se) { Trace.WriteLine(string.Format("doChat - SocketException : {0}", se.Message)); if (clientSocket != null) { if (OnDisconnected != null) { OnDisconnected(ref clientSocket); } clientSocket.Close(); stream.Close(); } } catch (Exception ex) { Trace.WriteLine(string.Format("doChat - Exception : {0}", ex.Message)); if (clientSocket != null) { if (OnDisconnected != null) { OnDisconnected(ref clientSocket); } clientSocket.Close(); stream.Close(); } } }
protected void OnNetworkAction(SocketState state) { if (state.ErrorOccurred) { OnDisconnected?.Invoke(this); return; } string data = state.GetData(); OnReceived?.Invoke(this, data); state.RemoveData(0, data.Length); Networking.GetData(state); }
/// <summary> /// 接收字节流 /// </summary> /// <param name="param"></param> /// <param name="buffer"></param> /// <returns></returns> public void Receive(string param, byte[] buffer) { try { if (OnReceived != null) { OnReceived.BeginInvoke(param, buffer, null, null); } } catch (Exception ex) { TraceLog.WriteError("WcfCallback receive error:{0}", ex); } }
public static void AsyncReceiveFixed(this Socket socket, byte[] buffer, int offset, int len, OnReceived receivedCallback, object state) { socket.BeginReceive(buffer, offset, len, SocketFlags.None, ar => { var received = socket.EndReceive(ar); if (received == 0) receivedCallback.Invoke(state, null); if (received < len) AsyncReceiveFixed(socket, buffer, offset + received, len - received, receivedCallback, state); else receivedCallback.Invoke(state, buffer); }, state); }
public Task StartAsync(CancellationToken ct = default) { _cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(ct); _hostTransportTasks = new List <Task>(); foreach (var hostTransport in _hostTransports) { hostTransport.OnConnected += (p, e, s) => OnConnected?.Invoke(p, e, s); hostTransport.OnReceived += (p, e, m) => OnReceived?.Invoke(p, e, m); hostTransport.OnClosed += (p, e, s) => OnClosed?.Invoke(p, e, s); _hostTransportTasks.Add(hostTransport.StartAsync(ct)); } return(Task.WhenAll(_hostTransportTasks)); }
public static void AsyncReceiveFixed(this Socket socket, byte[] buffer, OnReceived receivedCallback, object state) { AsyncReceiveFixed(socket, buffer, 0, buffer.Length, receivedCallback, state); }