private void DealWithFeedBack(ReadWriteObject rwObj, int count) { byte[] b = new byte[count]; Array.Copy(rwObj.ReadBytes, 0, b, 0, count); SendData(b); OnReceiveMessage?.Invoke(Message.Parser.ParseFrom(b)); }
private void Connect() { connection.On <string, string>("ReceiveMessage", (user, message) => { OnReceiveMessage?.Invoke(user, message); }); }
/// <summary> /// Runs in background clientReceiveThread; Listens for incomming data. /// </summary> private void ListenForData() { try { socketConnection = new TcpClient(Hostname, Port); Byte[] bytes = new Byte[1024]; while (true) { // Get a stream object for reading using (NetworkStream stream = socketConnection.GetStream()) { int length; // Read incomming stream into byte arrary. while ((length = stream.Read(bytes, 0, bytes.Length)) != 0) { var incommingData = new byte[length]; Array.Copy(bytes, 0, incommingData, 0, length); // Convert byte array to string message. string serverMessage = Encoding.ASCII.GetString(incommingData); OnReceiveMessage?.Invoke(serverMessage); } } } } catch (SocketException socketException) { Debug.Log("Socket exception: " + socketException); socketConnection = null; } }
private void WebSocketClient_OnReceiveMessage(WebSocketClient.Core.WebSocketClient webSocketClient, string message) { if (OnReceiveMessage != null) { OnReceiveMessage.Invoke(this, Newtonsoft.Json.JsonConvert.DeserializeObject <ReceiveMessage>(message)); } }
internal void CheckMessages() { while (ReceiveMessagesQueue.TryDequeue(out var message)) { OnReceiveMessage?.Invoke(message); } }
public void Client_OnReceive(IAsyncResult asyncResult) { int receivedSize = Client.EndReceive(asyncResult); if (receivedSize > 0) { ReceivedContent.Append(Encoding.ASCII.GetString(Buffer, 0, receivedSize)); string content = ReceivedContent.ToString(); int indexOfEndOfFile = content.IndexOf(EOF); while (indexOfEndOfFile > -1) { var currentContent = content.Substring(0, indexOfEndOfFile); content = content.Substring(indexOfEndOfFile + EOF.Length); ReceivedContent = new StringBuilder(content); OnReceiveMessage?.Invoke(currentContent); indexOfEndOfFile = content.IndexOf(EOF); } } if (!Client.Connected) { OnDisconnected?.Invoke(); } else if (!CancellationToken.IsCancellationRequested) { Client.BeginReceive(Buffer, 0, BufferSize, SocketFlags.None, new AsyncCallback(Client_OnReceive), null); } }
/// <summary> /// 异步发送消息 /// </summary> /// <param name="tcpClient">客户端套接字</param> /// <param name="message">发送消息</param> public void AsynSend(string message) { Message m = new Message { Name = tcpClient.LocalEndPoint.ToString(), Content = message }; byte[] sendBytes; using (MemoryStream stream = new MemoryStream()) { // Save the person to a stream m.WriteTo(stream); sendBytes = stream.ToArray(); } tcpClient.BeginSend(sendBytes, 0, sendBytes.Length, SocketFlags.None, asyncResult => { //完成发送消息 int length = tcpClient.EndSend(asyncResult); OnReceiveMessage?.Invoke(new Message() { Name = "Client", Content = message }); }, null); }
/// <summary> /// 异步递归接受消息 /// </summary> /// <returns></returns> public async Task ReceiveMessageAsync() { ArraySegment <byte> receiveBuffer = new ArraySegment <byte>(new byte[1024]); CancellationToken cancel = new CancellationToken(); WebSocketReceiveResult webSocketReceiveResult; try { webSocketReceiveResult = await ClientWebSocket.ReceiveAsync(receiveBuffer, cancel); } catch (Exception ex) { PrintHelper.printError(ex, log); await CloseAsync(WebSocketCloseStatus.ProtocolError, "WebSocket 连接异常" + GetExceptionMessge(ex)); return; } byte[] bytes = new byte[webSocketReceiveResult.Count]; Array.Copy(receiveBuffer.Array, bytes, webSocketReceiveResult.Count); if (!webSocketReceiveResult.CloseStatus.HasValue) { if (OnReceiveMessage != null) { OnReceiveMessage.Invoke(this, Encoding.GetString(bytes)); } await ReceiveMessageAsync(); } else { PrintHelper.PrintInfo($"连接被关闭:服务器关闭码【{webSocketReceiveResult.CloseStatus.Value}】,原因【{webSocketReceiveResult.CloseStatusDescription}】", log); await CloseAsync(webSocketReceiveResult.CloseStatus.Value, webSocketReceiveResult.CloseStatusDescription); } }
static int set_Receive(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); SingleWeb obj = (SingleWeb)o; OnReceiveMessage arg0 = null; LuaTypes funcType2 = LuaDLL.lua_type(L, 2); if (funcType2 != LuaTypes.LUA_TFUNCTION) { arg0 = (OnReceiveMessage)ToLua.CheckObject(L, 2, typeof(OnReceiveMessage)); } else { LuaFunction func = ToLua.ToLuaFunction(L, 2); arg0 = DelegateFactory.CreateDelegate(typeof(OnReceiveMessage), func) as OnReceiveMessage; } obj.Receive = arg0; return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index Receive on a nil value" : e.Message)); } }
public void Execute(OnReceiveMessage pipelineEvent) { var parser = pipelineEvent.Pipeline.State.Get <MsmqUriParser>(); var tx = pipelineEvent.Pipeline.State.Get <MessageQueueTransaction>(); try { pipelineEvent.Pipeline.State.Add( pipelineEvent.Pipeline.State.Get <MessageQueue>("queue") .Receive(pipelineEvent.Pipeline.State.Get <TimeSpan>("timeout"), tx)); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { pipelineEvent.Pipeline.State.Add <Message>(null); return; } if (ex.MessageQueueErrorCode == MessageQueueErrorCode.AccessDenied) { MsmqQueue.AccessDenied(_log, parser.Path); } _log.Error(string.Format(MsmqResources.GetMessageError, parser.Uri, ex.Message)); throw; } }
public Subscriber(OnReceiveMessage <T> aCallback, bool aStartSubscribing) { myOnReceiveMessage = aCallback; if (aStartSubscribing == true) { Subscribe(); } }
private void Consumer_Received1(object sender, BasicDeliverEventArgs e) { var message = Encoding.UTF8.GetString(e.Body); OnReceiveMessage?.Invoke(this, new MessageEventArgs(message)); _channel.BasicAck(deliveryTag: e.DeliveryTag, multiple: false); }
public void Init(string url, bool useHttps) { var port = string.Empty; // ios || android if (url.Equals("localhost") || url.Equals("10.0.2.2")) { port = useHttps ? ":5001" : ":5000"; } string completeUrl = string.Format("http{0}://{1}{2}/hubs/chat", useHttps ? "s" : string.Empty, url, port); hubConnection = new HubConnectionBuilder().WithUrl(completeUrl).Build(); // Closing connection hubConnection.Closed += async(error) => { OnConnectionClosed?.Invoke(this, new MessageEventArgs("", "Closing connection")); connected = false; // Reconnect await Task.Delay(3000); try { await ConnectAsync(); } catch (Exception e) { Debug.WriteLine(e); } }; // Joining/leaving a group hubConnection.On <string>("EnterOrLeave", (message) => { OnEnterOrLeave?.Invoke(this, new MessageEventArgs(message, message)); }); hubConnection.On <string>("Enter", (user) => { OnEnterOrLeave?.Invoke(this, new MessageEventArgs(user, $"{user} joined")); }); hubConnection.On <string>("Leave", (user) => { OnEnterOrLeave?.Invoke(this, new MessageEventArgs(user, $"{user} left")); }); // Receive message hubConnection.On <string, string>("ReceiveMessage", (user, message) => { OnReceiveMessage?.Invoke(this, new MessageEventArgs(user, message)); }); }
/// <summary> /// Remove a listener /// </summary> /// <param name="action">The action to remove</param> public void RemoveListener(OnReceiveMessage action) { listeners.Remove(action); #if SHOW_DEBUG_INFO if (onUpdateListeners != null) { onUpdateListeners(listeners); } #endif }
/// <summary> /// Raised when a new line was received. /// </summary> /// <param name="sender">Sender.</param> /// <param name="e">E.</param> private static void NewLineReceived(object sender, CommandEventArgs e) { #if DEBUG Console.WriteLine(@"Received > " + e.Command.CommandString()); #endif if (OnReceiveMessage != null) { OnReceiveMessage.Invoke(null, new CommunicationArgs(e.Command.CommandString())); } LastCommunication = DateTime.Now; }
public Client(TcpClient client, OnReceiveMessage onReceiveMessage) { this.onReceiveMessage = onReceiveMessage; ns = client.GetStream(); streamReader = new StreamReader(ns); ThreadStart ts = new ThreadStart(StartTread); tread = new Thread(ts); tread.Start(); }
public static void ActOnMessage(Message message) { if (message.Type == MsgType.Ack) { Log.Info(_tag, $"Received client ack of {message.Content}"); } else { OnReceiveMessage.Raise(message); var doThis = ParseMessageToAction(message); doThis?.Invoke(BaseActivity.CurrentActivity); // Note - nothing (currently) actually *uses* the argument of doThis; passing it the current activity is basically a placeholder here. } }
/// <summary> /// 异步连接客户端回调函数 /// </summary> /// <param name="tcpClient"></param> private void AsynRecive() { byte[] data = new byte[2048]; tcpClient.BeginReceive(data, 0, data.Length, SocketFlags.None, asyncResult => { int length = tcpClient.EndReceive(asyncResult); if (length > 0) { Message message = Message.Parser.ParseFrom(data, 0, length); OnReceiveMessage?.Invoke(message); } AsynRecive(); }, null); }
public async void MessageListener() { byte[] intBuffer = new byte[IntBytes]; while (!disposed && networkStream != null) { try { int lengthBytesRead = await networkStream.ReadAsync(intBuffer, 0, IntBytes, disposeCancellationSource.Token); // Socket has been disconnected if (lengthBytesRead <= 0) { Disconnect(); break; } int length = BitConverter.ToInt32(intBuffer, 0); // Handle empty messages asap if (length == 0) { OnReceiveMessage?.Invoke(this, ""); } else if (length < 0) { OnReceiveMessage?.Invoke(this, null); } byte[] messageBuffer = new byte[length]; int messageBytesRead = await networkStream.ReadAsync(messageBuffer, 0, length, disposeCancellationSource.Token); // Socket has been disconnected if (messageBytesRead <= 0) { Disconnect(); break; } string message = Encoding.GetString(messageBuffer, 0, length); OnReceiveMessage?.Invoke(this, message); } catch (Exception e) { Program.LogDebugException(nameof(MessageListener), e); } } }
/// <summary> /// Listen to the message with the given id /// </summary> /// <param name="id">id of the message to listen for</param> /// <param name="action">The action to run when the message is received</param> public void AddListener(string id, OnReceiveMessage action) { if (!listeners.ContainsKey(action)) { listeners.Add(action, id); } #if SHOW_DEBUG_INFO if (onUpdateListeners != null) { onUpdateListeners(listeners); } #endif }
/// <summary> /// Tcp协议异步连接服务器 /// </summary> public Client AsynConnect() { //主机IP tcpClient.BeginConnect(serverIp, asyncResult => { tcpClient.EndConnect(asyncResult); OnReceiveMessage?.Invoke(new Message() { Name = "Client", Content = $"Connected {serverIp.ToString()}" }); AsynRecive(); }, null); return(this); }
private void Enqueue(IConsoleLogMessage message) { if (message.Type > MaxLogLevel) { return; } if (LogHistory.Count > MaxLogRegister) { LogHistory.Dequeue(); } LogHistory.Enqueue(message); OnReceiveMessage?.Invoke(message); }
private void AcceptTcpClientCallback(IAsyncResult ar) { TcpListener myListener = ar.AsyncState as TcpListener; TcpClient client = myListener.EndAcceptTcpClient(ar); OnReceiveMessage?.Invoke(new Message() { Name = "Server", Content = $"Connected {client.Client.RemoteEndPoint.ToString()}" }); ReadWriteObject readWriteObject = new ReadWriteObject(client); rwoList.Add(readWriteObject); readWriteObject.BeginRead(ReadCallback); AcceptConnect(); }
public void Init(string urlRoot, bool useHttps) { random = new Random(); var port = (urlRoot == "localhost" || urlRoot == "10.0.2.2") ? (useHttps ? ":5001" : ":5000") : String.Empty; var url = $"http{(useHttps ? "s" : String.Empty)}://{urlRoot}{port}/hub/chat"; hubConnection = new HubConnectionBuilder() .WithUrl(url) .Build(); hubConnection.Closed += async(error) => { OnConnectionClosed?.Invoke(this, new MessageEventArgs("Connection closed...", String.Empty)); IsConnected = false; await Task.Delay(random.Next(0, 5) * 1000); try { await ConnectAsync(); } catch (Exception ex) { Debug.WriteLine(ex); } }; hubConnection.On <string, string>("ReceiveMessage", (user, message) => { OnReceiveMessage?.Invoke(this, new MessageEventArgs(message, user)); }); hubConnection.On <string>("Entered", (user) => { OnEnteredOrExisted?.Invoke(this, new MessageEventArgs($"{user} entered...", user)); }); hubConnection.On <string>("Left", (user) => { OnEnteredOrExisted?.Invoke(this, new MessageEventArgs($"{user} left...", user)); }); hubConnection.On <string>("EnterOrLeft", (message) => { OnEnteredOrExisted?.Invoke(this, new MessageEventArgs(message, message)); }); }
private void Poll() { while (Enabled) { //Get next message var deliveryArgs = _subscription.Next(); //Deserialize message var message = Encoding.Default.GetString(deliveryArgs.Body); var dsMessage = JsonConvert.DeserializeObject <T>(message); OnReceiveMessage.Invoke(this, new RecieveMessageArgs <T> { Data = dsMessage }); //Acknowledge message is processed _subscription.Ack(deliveryArgs); } }
static int get_Receive(IntPtr L) { object o = null; try { o = ToLua.ToObject(L, 1); SingleWeb obj = (SingleWeb)o; OnReceiveMessage ret = obj.Receive; ToLua.Push(L, ret); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index Receive on a nil value" : e.Message)); } }
public void ListenMessage() { IPEndPoint IpFrom = new IPEndPoint(IPAddress.Any, 0); while (true) { var rcvMessage = System.Text.Encoding.UTF8.GetString(UdpClient.Receive(ref IpFrom)); OnReciveMessageEventArgs args = new OnReciveMessageEventArgs { IP = IpFrom.Address.ToString(), Message = rcvMessage }; if (OnReceiveMessage != null) { OnReceiveMessage.Invoke(this, args); } } }
private void ReceiveCallback(IAsyncResult ar) { try { if (ar.IsCompleted) { IPEndPoint epp = new IPEndPoint(IPAddress.Any, 0); byte[] buff = socket.EndReceive(ar, ref epp); ar.AsyncWaitHandle.Close(); OnReceiveMessage?.Invoke(epp, buff); //socket.Send(back, back.Length, epp); socket.BeginReceive(ReceiveCallback, null); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
internal void ReceiveMessage(BoundUserInterfaceMessage wrappedMessage, IPlayerSession session) { if (!_subscribedSessions.Contains(session)) { Logger.DebugS("go.comp.ui", "Got message from session not subscribed to us."); return; } switch (wrappedMessage) { case CloseBoundInterfaceMessage _: _subscribedSessions.Remove(session); break; default: OnReceiveMessage?.Invoke(wrappedMessage); break; } }
public fBase(IJobAction jobAction) { StoreMessages = new QueueThreadSafe <Message>(); JobAction = jobAction; //store.f_form_Add(this); //this.FormClosing += (se, ev) => { store.f_form_Remove(this); }; timer_api = new System.Threading.Timer(new System.Threading.TimerCallback((obj) => { IFORM form = (IFORM)obj; if (StoreMessages.Count > 0) { Message m = StoreMessages.Dequeue(null); if (m != null) { OnReceiveMessage?.Invoke(form, m); } } }), this, 100, 100); }
/// <summary> /// Listen to the message with the given id /// </summary> /// <param name="id">id of the message to listen for</param> /// <param name="action">The action to run when the message is received</param> public void AddListener (string id, OnReceiveMessage action) { if (!listeners.ContainsKey (action)) listeners.Add (action, id); #if SHOW_DEBUG_INFO if (onUpdateListeners != null) onUpdateListeners (listeners); #endif }
/// <summary> /// Remove a listener /// </summary> /// <param name="action">The action to remove</param> public void RemoveListener (OnReceiveMessage action) { listeners.Remove (action); #if SHOW_DEBUG_INFO if (onUpdateListeners != null) onUpdateListeners (listeners); #endif }
public Client(TcpClient client , OnReceiveMessage onReceiveMessage) { this.onReceiveMessage = onReceiveMessage; ns = client.GetStream(); streamReader = new StreamReader(ns); ThreadStart ts = new ThreadStart(StartTread); tread = new Thread(ts); tread.Start(); }