private void LongPollEventLoop() { //Запускаем бесконечный цикл опроса try { while (true) { var longPollHistoryResponse = _api.Groups.GetBotsLongPollHistory(new BotsLongPollHistoryParams { Ts = ts.ToString(), Key = key, Server = server, Wait = 10 }); ts = longPollHistoryResponse.Ts; foreach (var update in longPollHistoryResponse.Updates) { if (update.Type.ToString() == "message_new") { OnNewMessage.Invoke( update.MessageNew.Message ); } } } } catch (Exception) { StartMessageHandling(); return; } }
public override void OnReceive(ReadOnlySpan <byte> data) { base.OnReceive(data); Span <byte> headerSpan = headerPayload; while (RecvBuffer.Peek(headerSpan) == 4) { if (BitConverter.IsLittleEndian) { headerSpan.Reverse(); } var payloadLength = BitConverter.ToInt32(headerSpan); if (payloadLength > payload.Length) { throw new IndexOutOfRangeException("not enough buffer for message"); } if (payloadLength + 4 <= RecvBuffer.Length) { RecvBuffer.Skip(4); Span <byte> messageSpan = payload; messageSpan = messageSpan.Slice(0, payloadLength); var count = RecvBuffer.Take(messageSpan); OnNewMessage?.Invoke(messageSpan, count); } else { break; } } }
private void Process() { while (IsActive) { try { ItemMessage message; if (_messages.TryDequeue(out message)) { var isNew = FileMode.Append; if (GetPathToTextLog()) { isNew = FileMode.Create; } OnNewMessage?.Invoke(message); Debug.WriteLine(message.ToString()); using (var writer = new StreamWriter(new FileStream(_fi.FullName, isNew))) { writer.WriteLine(message.ToString()); } continue; } Thread.Sleep(500); } catch (Exception) { } } }
public async Task GetStreamTweets(string tag) { await (from strm in _twitterCtx.Streaming where strm.Type == StreamingType.Filter && strm.Track == tag select strm) .StartAsync(strm => { if (strm.EntityType == StreamEntityType.Status) { var status = strm.Entity as Status; if (status.Entities != null) { if (status.Entities.MediaEntities != null && status.Entities.MediaEntities.Count > 0 && status.RetweetedStatus.CreatedAt == DateTime.MinValue) { OnNewMessage?.Invoke(this, new GenericEventArgs <Status> { Data = status }); } } } return(Task.FromResult(0)); }); }
private void HandleOnChanged(object sender, RecordChangedEventArgs <Message> e) { if (e.ChangeType == TableDependency.SqlClient.Base.Enums.ChangeType.Insert) { OnNewMessage?.Invoke(e.Entity); } }
public ChatBL() { server = ServerBL.Instance; server.chatHubProxy.On("newMessage", (string room, string msg) => OnNewMessage?.Invoke(room, msg)); server.chatHubProxy.On("ChatClosed", (string room, string sender) => OnChatClosed?.Invoke(room, sender)); }
public void Set(RequestMessage message) { if (_isReleased) { return; } Task.Run(() => OnNewMessage?.Invoke(this, message)); }
public static void Message(MessageStatus status, string message, bool sendtoserver = false) { if (sendtoserver) { ConnectionToServer.SendMessageToServer(status, message); } OnNewMessage?.Invoke(status, message); }
public void Warn(string message, [CallerMemberName] string callerMemberName = "") { OnNewMessage?.Invoke(this, new LogMessage { Level = "WARN", Message = message, CallingMemberName = callerMemberName }); }
public void Error(string message, [CallerMemberName] string callerMemberName = "") { OnNewMessage?.Invoke(this, new LogMessage { Level = "ERROR", Message = message, CallingMemberName = callerMemberName }); }
} // ServerThread() private void EventThread(object command) { var commandString = command as string; if (!string.IsNullOrEmpty(commandString)) { OnNewMessage?.Invoke(this, new MessageEventArgs(commandString)); } } // EventThread()
public void Debug(string message, [CallerMemberName] string callerMemberName = "") { OnNewMessage?.Invoke(this, new LogMessage { Level = "DEBUG", Message = message, CallingMemberName = callerMemberName }); }
private void StartTcpReceivingThread() { OnNewMessage += _messageManager.HandleMessage; StringBuilder stringBuilder = new StringBuilder(); var receivingThread = new Thread(() => { string oneResponse; while (true) { if (_socket != null && _socket.Connected) { try { // //StringBuilder stringBuilder = new StringBuilder(); // var bytes = new byte[250]; // var numBytesReadFromStream = _socket.Receive(bytes); // if (numBytesReadFromStream > 0) { using (NetworkStream ns = new NetworkStream(_socket)) using (StreamReader sr = new StreamReader(ns)) OnNewMessage?.Invoke(this, sr.ReadLine()); //stringBuilder.Append(sr.ReadLine()); //Debug.WriteLine(sr.ReadToEnd()); //; //oneResponse = _tcpReceiver.Receive(_socket, stringBuilder); //if (!string.IsNullOrEmpty(oneResponse)) // { //stringBuilder.Append(Encoding.ASCII.GetString(bytes)); //OnNewMessage?.Invoke(this, Encoding.ASCII.GetString(bytes)); //} // stringBuilder.Append(Encoding.ASCII.GetString(bytes)); } //if (numBytesReadFromStream == 0) //{ //string s = stringBuilder.ToString(); //Debug.WriteLine(s); //} /*if (!string.IsNullOrEmpty(oneResponse)) * { * OnNewMessage?.Invoke(this, oneResponse); * } */ } catch (Exception e) { Console.WriteLine(e.Message); } } } }); receivingThread.Start(); }
public override void OnReceive(ReadOnlySpan <byte> data) { base.OnReceive(data); Span <byte> header = headerPayload; while (streamReadBytesLeft == 0 && RecvBuffer.Peek(header) == 12) { // use network endian var messageType = BinaryPrimitives.ReadInt32BigEndian(header); var payloadLength = BinaryPrimitives.ReadInt64BigEndian(header.Slice(4)); if (messageType == MessageType.Message) { if (payloadLength > payloadBuffer.Length) { throw new IndexOutOfRangeException( $"Message({payloadLength}) is too big to fit into the buffer({payloadBuffer.Length})"); } if (payloadLength + 12 <= RecvBuffer.Length) { RecvBuffer.Skip(12); Span <byte> messageSpan = payloadBuffer; messageSpan = messageSpan.Slice(0, (int)payloadLength); var count = RecvBuffer.Take(messageSpan); OnNewMessage?.Invoke(messageSpan, count); } else { break; } } else if (messageType == MessageType.ByteStream) { if (memoryStream == null) { memoryStream = new MemoryStream(1024 * 1024 * 4); } memoryStream.SetLength(0); memoryStream.Seek(0, SeekOrigin.Begin); streamReadBytesLeft = payloadLength; RecvBuffer.Skip(12); DrainStreamPayload(); } } while (streamReadBytesLeft > 0) { if (DrainStreamPayload() == 0) { break; } } }
private void InvokeNewMessageHandler(BroadcastedMessage message) { try { OnNewMessage?.Invoke(this, message); } catch (Exception e) { throw new Exception($"Error thrown by OnNewMessage handler! Error: {e.Message} \n {e.InnerException?.Message}"); } }
public override void OnMessage(string message) { string key = GetClientKey(this); Type objType = GeneXus.Metadata.ClassLoader.FindType("GeneXus", GX_NOTIFICATIONINFO_NAME, null); GxUserType nInfo = (GxUserType)Activator.CreateInstance(objType); JObject jObj = new JObject(); jObj.Put("Message", message); nInfo.FromJSONObject(jObj); ExecuteHandler(HandlerType.ReceivedMessage, new Object[] { key, nInfo }); OnNewMessage?.Invoke(key, message); }
internal void WriteMessage(Entry entry) { if (entry == null) { throw new ArgumentNullException(nameof(entry)); } Messages.Add(entry); if (OnNewMessage != null) { OnNewMessage.Invoke(this, entry); } }
private void _server_DataReceived(object sender, Message e) { Console.WriteLine("Packet Weight : " + e.Data.Count() + " bytes"); Thread thread = new Thread(delegate() { var tmp = SimpleTcpAdapter.Convert(e.TcpClient); var packet = new BasicPacket(); if (!packet.Parse(e.Data)) { var packets = SplitPacket(e.Data); foreach (var pk in packets) { Thread.Sleep(500); Thread t = new Thread(delegate() { var pack = new BasicPacket(); if (!pack.Parse(pk)) { return; } var ptc = ProtocolFactory.CreateProtocol(pack.Opcode); if (!ptc.Parse(Encoding.Unicode.GetString(pack.Data))) { return; } var handling = HandleFactory.CreateHandle(pack.Opcode); string toview = handling.Handling(ptc, tmp); if (OnNewMessage != null) { OnNewMessage.Invoke(tmp, toview); } }); t.Start(); } return; } var protocol = ProtocolFactory.CreateProtocol(packet.Opcode); if (!protocol.Parse(Encoding.Unicode.GetString(packet.Data))) { return; } var handle = HandleFactory.CreateHandle(packet.Opcode); string toView = handle.Handling(protocol, tmp); if (OnNewMessage != null) { OnNewMessage.Invoke(tmp, toView); } }); thread.Priority = ThreadPriority.Highest; thread.Start(); }
public override Task OnMessage(string connectionGUID, System.Net.WebSockets.WebSocket socket, WebSocketReceiveResult result, byte[] buffer) { string key = connectionGUID; string message = Encoding.UTF8.GetString(buffer); Type objType = GeneXus.Metadata.ClassLoader.FindType("GeneXus", GX_NOTIFICATIONINFO_NAME, null); GxUserType nInfo = (GxUserType)Activator.CreateInstance(objType); JObject jObj = new JObject(); jObj.Put("Message", message); nInfo.FromJSONObject(jObj); ExecuteHandler(HandlerType.ReceivedMessage, new Object[] { key, nInfo }); OnNewMessage?.Invoke(key, message); return(Task.CompletedTask); }
private void ProcessData(byte[] bytes, int count) { for (int i = 0; i < count; i++) { byte b = bytes[i]; if (b == _delimByte) { // Message done! byte[] message = _currentMessage.ToArray(); _currentMessage.Clear(); _escaped = false; OnNewMessage?.Invoke(message); } else if (b == _escapeByte) { _escaped = true; } else if (_escaped) { _escaped = false; switch (b) { case _escapeEscapeByte: _currentMessage.Add(_escapeByte); break; case _escapeDelimByte: _currentMessage.Add(_delimByte); break; case _closeConnection: OnCloseConnection?.Invoke(); SocketClose(); return; default: // Unrecognized escape sequence! break; } } else { _currentMessage.Add(b); } } }
/// <summary> /// Event handler to get new message from socket /// </summary> private void Socket_OnMessage(object sender, MessageEventArgs e) { try { OnNewMessage?.Invoke(e.Data); // unzip data //if (e.IsBinary) // OnNewMessage?.Invoke(unzip(e.RawData)); } catch (Exception ex) { logger.Fatal(ex, "Websocket OnMessage Exception"); } }
private void SendMessage() { string message = _inputField.text; if (string.IsNullOrEmpty(message)) { return; } AddMessage(message, true); _inputField.text = ""; _inputField.ActivateInputField(); NewMessage?.Invoke(this, message); }
private void WriteMessage(MessageEventArgs <TSub> msgArgs) { // Если отправитель это текущий подписчик, то выводится - кому было направлено -> "To {messageEventArgs.To}" if (msgArgs.From.Equals(Subscriber)) { msgArgs.Message = $"{FormatDate(msgArgs.DateCreated)} " + $"To {msgArgs.To}: {msgArgs.Text}{Environment.NewLine}"; } else // Если же сообщение пришло от другого контроллера, то: { msgArgs.Message = $"{FormatDate(msgArgs.DateCreated)} " + $"{msgArgs.From}: {msgArgs.Text}{Environment.NewLine}"; } OnNewMessage.Invoke(this, msgArgs); }
private void _webSocket_OnMessage(string message) { try { if (Debug) { WriteLine($"New Message, Message: {message}"); } _lastMessageTime = DateTime.Now; // check if this is a keep alive if (message == "{{}}") { return; } if (message.Trim() == "") { return; } var msg = JsonConvert.DeserializeObject <WsResponse>(message); if (msg.S != null && msg.S == 1) { // this is an init message lets confirm SignalR.Start(_httpHost, _connectionToken, _hubs); return; } // record the related info _lastMessageId = msg.C; if (!string.IsNullOrEmpty(msg.G)) { _groupsToken = msg.G; } // invoke the event if (msg.M != null && msg.M.Any() || msg.R != null || !string.IsNullOrEmpty(msg.I) || !string.IsNullOrEmpty(msg.C)) { Task.Run(() => { OnNewMessage?.Invoke(msg); }); } } catch (Exception e) { Console.WriteLine($"SignalR Message Error: {e.Message}"); } }
internal override bool DoWork() { try { if (!_connection.TryReceiveMessage(out var serializedMessage)) { return(false); } OnNewMessage?.Invoke(serializedMessage); } catch (Exception e) { throw new ConnectionException("Cannot receive a message", e); } return(true); }
void ConveyorProcedure() { while (!_exitToken) { while (true) { RequestMessage message; _queue.TryDequeue(out message); if (message == null) { break; } OnNewMessage?.Invoke(this, message); } _onNewMessage.WaitOne(4000); } }
/// <summary> /// 处理接受的数据 /// </summary> /// <param name="socket"></param> private void Recieve(IAsyncResult socket) { Socket SockeClient = (Socket)socket.AsyncState; string IP = SockeClient.RemoteEndPoint.ToString(); if (SockeClient == null || !SessionPool.ContainsKey(IP)) { return; } var client = SessionPool[IP]; string clientMsg = string.Empty; try { int length = SockeClient.EndReceive(socket); if (length == 0) { Disconnect(client, IP); return; } byte[] buffer = SessionPool[IP].buffer; SockeClient.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(Recieve), SockeClient); try { clientMsg = AnalyzeClientData(buffer, length); } catch (Exception ex) { MessageBox.Show($"处理客户端数据时发生异常:{ex.Message}"); } } catch (Exception ex) { MessageBox.Show("接收客户端数据时发生异常:" + ex.Message); try { SockeClient.Disconnect(true); } catch { } Disconnect(client, IP); } OnNewMessage?.Invoke(this, new ClientNewMessageEventArgs(client, clientMsg)); }
internal override bool DoWork() { if (!_messageQueue.TryDequeue(out var serializedMessage)) { return(false); } try { var message = _dataContractOperations.Deserialize(serializedMessage); OnNewMessage?.Invoke(message); } catch (Exception e) { throw new SerializationException("Cannot deserialize the emessage.", e); } return(true); }
private async Task GetMessages() { _cts = new CancellationTokenSource(); try { while (await _stream.ResponseStream.MoveNext(_cts.Token)) { var m = _stream.ResponseStream.Current; var token = _cts.Token; Interfaces.AnalogyLogMessage msg = new Interfaces.AnalogyLogMessage() { Category = m.Category, Level = (AnalogyLogLevel)m.Level, Class = (AnalogyLogClass)m.Class, Date = m.Date.ToDateTime().ToLocalTime(), FileName = m.FileName, LineNumber = m.LineNumber, MachineName = m.MachineName, MethodName = m.MethodName, Module = m.Module, ProcessId = m.ProcessId, Source = m.Source, Text = m.Text, ThreadId = m.ThreadId, User = m.User }; msg.Id = string.IsNullOrEmpty(m.Id) ? Guid.NewGuid() : Guid.TryParse(m.Id, out Guid id) ? id : Guid.NewGuid(); OnNewMessage?.Invoke(this, msg); if (token.IsCancellationRequested) { break; } } } catch (Exception e) { OnError?.Invoke(this, e.Message); } }
private void ConnectSocketClient() { if (_socketClient != null) { return; } _socketClient = CreateClient(_token); if (_socketClient == null) { return; } _socketClient.OnMessageReceived += msg => { var channelMsg = msg.ToChannelMessage(); _newMessages.Add(channelMsg); OnNewMessage?.Invoke(channelMsg); }; }