private void Callback_OnReceive(IAsyncResult result) { try { ReceiveStateObject obj = (ReceiveStateObject)result.AsyncState; int recvBytes = _socket.EndReceive(result); if (0 == recvBytes) { Close(); return; } obj.buffer.writeIndex += recvBytes; ReceiveEvent evt = new ReceiveEvent(); evt.session = this; evt.buffer = obj.buffer; eventQueue.Enqueue(evt); Receive(); } catch (System.Exception error) { Error(error); } }
public ColorMessage DispatchReceiveColorMessage(ColorMessage colorMessage) { if (ReceiveEvent == null) { return(colorMessage); } foreach (ReceiveEventDelegate del in ReceiveEvent.GetInvocationList()) { try { colorMessage = del(colorMessage); } catch (Exception e) { ChiConsole.WriteError("Error calling colormessage handler", e); } if (colorMessage == null) { break; } } return(colorMessage); }
public void AddListener <T>(ReceiveEvent eventID, Action <T> eventHandler) { foreach (int id in eventID.receivingEvents) { compositeEventManager.AddListener <T>(id, eventHandler); } }
public void TestSend() { string q = "me"; string appKey = "3c0a72612269ebac"; string from = "zh-CHS"; string to = "en"; string salt = DateTime.Now.Millisecond.ToString(); string appSecret = "tJN4pmDy34ET8aLZmADUjCIs2YLx0OaS"; MD5 md5 = new MD5CryptoServiceProvider(); string md5Str = appKey + q + salt + appSecret; byte[] output = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(md5Str)); string sign = BitConverter.ToString(output).Replace("-", ""); string url = string.Format("http://openapi.youdao.com/api?appKey={0}&q={1}&from={2}&to={3}&sign={4}&salt={5}", appKey, System.Web.HttpUtility.UrlDecode(q, System.Text.Encoding.GetEncoding("UTF-8")), from, to, sign, salt); WebRequest translationWebRequest = WebRequest.Create(url); WebResponse response = null; response = translationWebRequest.GetResponse(); Stream stream = response.GetResponseStream(); Encoding encode = Encoding.GetEncoding("utf-8"); StreamReader reader = new StreamReader(stream, encode); string result = reader.ReadToEnd(); //result = GetJsonNode(result, "basic"); ReceiveEvent?.Invoke(Json.ConvertJsonString(result)); //Debug.WriteLine(result); }
async Task Receive() { var s = await _client.ReceiveAsync(); ReceiveEvent?.Invoke(s.Buffer); Receive(); }
private void Callback_Receive(IAsyncResult result) { try { lock (this) { Gamnet.Buffer buffer = (Gamnet.Buffer)result.AsyncState; int recvBytes = _socket.EndReceive(result); if (0 == recvBytes) { Debug.Log("socket read '0' byte. close socket"); Disconnect(); return; } buffer.write_index += recvBytes; ReceiveEvent evt = new ReceiveEvent(this); evt.buffer = buffer; _event_queue.Add(evt); Receive(); } } catch (SocketException e) { Debug.LogError("[Session.Callback_Receive] session_state:" + _state + ", exception:" + e.ToString()); if (ConnectionState.Disconnected == _state) { return; } Error(new Gamnet.Exception(ErrorCode.UndefinedError, e.ToString())); Disconnect(); } }
//########################################################################################### public void AddListener(ReceiveEvent eventID, Action eventHandler) { foreach (int id in eventID.receivingEvents) { eventManager.AddListener(id, eventHandler); } }
private void Callback_Receive(IAsyncResult result) { try { Gamnet.Buffer buffer = (Gamnet.Buffer)result.AsyncState; int recvBytes = _socket.EndReceive(result); if (0 == recvBytes) { Close(); return; } buffer.write_index += recvBytes; ReceiveEvent evt = new ReceiveEvent(this); evt.buffer = buffer; lock (_sync_obj) { _event_queue.Add(evt); } Receive(); } catch (SocketException e) { if (ConnectionState.Disconnected == _state) { return; } Error(new Gamnet.Exception(ErrorCode.UndefinedError, e.Message)); Close(); } }
void Receive(object socketObj) { Socket socket = socketObj as Socket; while (true) { int receiveCount; try { receiveCount = socket.Receive(_receiveBuffer); } catch (Exception e) { //关闭Link Close(NetExceptionType.Receive, e); return; } if (receiveCount == 0) { //关闭Link Close(NetExceptionType.OtherSideClose, new Exception("OtherSideClose")); return; } lock (_receiveTransitStream) { _receiveTransitStream.Oct.Write(_receiveBuffer, 0, receiveCount); } if (ReceiveEvent != null) { ReceiveEvent.Set(); } } }
private void Receive(string message) { if (verbose) { Debug.Log($"ZeroMQApi Receiving {subscriberIp}: {message}"); } ReceiveEvent?.Invoke(message); }
private void ReceiveCallback(IAsyncResult asyncResult) { byte[] receiveBytes = SNMPListener.EndReceive(asyncResult, ref ipEnPoint); ReceiveEventArgs receiveArgs = new ReceiveEventArgs(receiveBytes, ipEnPoint); ReceiveEvent.Invoke(this, receiveArgs); SNMPListener.BeginReceive(ReceiveCallback, new SNMPState(SNMPListener, ipEnPoint)); }
/// <summary> /// When you have received a data packet from the server and are done /// processing it in a HandleDATA-routine, call PostToHost() to trigger /// an event for this type. /// </summary> /// <typeparam name="T">Contains the data type for which the event is thrown. /// This can be safely ommitted.</typeparam> /// <param name="Event">Contains the event that is to be thrown.</param> /// <param name="id">Contains the Zusi command ID.</param> /// <param name="value">Contains the new value of the measure.</param> protected void PostToHost <T>(ReceiveEvent <T> Event, int id, T value) { if (Event == null) { return; } _hostContext.Post(EventMarshal <T>, new MarshalArgs <T>(Event, id, value)); }
private void SocketClient_onReceive(object sender, ReceiveEvent e) { if (__cSocket == e.ActiveSocket) { __iNoPacketCount1 = 0; } if (__cSession == e.ActiveSocket) { __iNoPacketCount2 = 0; } StockDecoder.Decode(e.ActiveSocket, e.Token, this.IsDecode); }
// Update is called once per frame void Update() { while (receiveBufferQueue.Count > 0) { byte[] _receiveBuffer = receiveBufferQueue.Dequeue(); if (ReceiveEvent != null) { ReceiveEvent.Invoke(_receiveBuffer); } } }
protected override void HandleEvent(object evt) { if (evt is ReceiveEvent) { ReceiveEvent e = (ReceiveEvent)evt; HandleBeacon(e.data, e.remoteEndPoint); } else if (evt is System.Exception) { throw (System.Exception)evt; } }
public void Dispose() { ReceiveEvent.UserToken = null; ReceiveEvent.Completed -= ReceiveSocketEvent_Completed; ReceiveEvent.SetBuffer(null); socketEventPool.Push(ReceiveEvent); SendEvent.UserToken = null; SendEvent.Completed -= SendSocketEvnet_Completed; socketEventPool.Push(SendEvent); }
public virtual void registerEventHandler(ComponentSystem handler) { Type handlerClass = handler.GetType(); if (!Modifier.isPublic(handlerClass.Modifiers)) { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: logger.error("Cannot register handler {}, must be public", handler.GetType().FullName); return; } //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: logger.debug("Registering event handler " + handlerClass.FullName); foreach (Method method in handlerClass.GetMethods()) { ReceiveEvent receiveEventAnnotation = method.getAnnotation(typeof(ReceiveEvent)); if (receiveEventAnnotation != null) { if (!receiveEventAnnotation.netFilter().isValidFor(networkSystem.Mode, false)) { continue; } Set <Type> requiredComponents = Sets.newLinkedHashSet(); method.Accessible = true; Type[] types = method.ParameterTypes; logger.debug("Found method: " + method.ToString()); if (!types[0].IsSubclassOf(typeof(Event)) || !types[1].IsSubclassOf(typeof(EntityRef))) { logger.error("Invalid event handler method: {}", method.Name); return; } requiredComponents.addAll(Arrays.asList(receiveEventAnnotation.components())); IList <Type> componentParams = Lists.newArrayList(); for (int i = 2; i < types.Length; ++i) { if (!types[i].IsSubclassOf(typeof(Component))) { logger.error("Invalid event handler method: {} - {} is not a component class", method.Name, types[i]); return; } requiredComponents.add((Type)types[i]); componentParams.Add((Type)types[i]); } ByteCodeEventHandlerInfo handlerInfo = new ByteCodeEventHandlerInfo(handler, method, receiveEventAnnotation.priority(), requiredComponents, componentParams); addEventHandler((Type)types[0], handlerInfo, requiredComponents); } } }
private SocketEventProvider(Session.Session session) { Sending = false; ReceiveEvent = socketEventPool.Pop(); ReceiveEvent.UserToken = session; ReceiveEvent.Completed += ReceiveSocketEvent_Completed; // TODO: Memory Manager ReceiveEvent.SetBuffer(new byte[MaxBufferSize]); SendEvent = socketEventPool.Pop(); SendEvent.UserToken = session; SendEvent.Completed += SendSocketEvnet_Completed; }
void Update() { if (_isGameStarted) { PollMovement(); ManageHud(); } ReceiveEvent recEvent = base.Receive(); if (recEvent.type == NetworkEventType.DataEvent) { Message message = recEvent.message; if (message.type == MessageType.SetUp) { SetUpMessage setupMessage = (SetUpMessage)message.GetData(); StartGame(setupMessage.activePlayers); } else if (message.type == MessageType.StateUpdate) { ChangeLog changes = (ChangeLog)message.GetData(); foreach (var kvp in _players) { if (!changes.PlayerLocations.ContainsKey(kvp.Key)) { kvp.Value.isDeadImage.SetActive(true); } } foreach (var playerTransform in changes.PlayerLocations) { CellID playerNum = playerTransform.Key; Vector2 position = (Vector2)playerTransform.Value; float rotation = playerTransform.Value.z; _players[playerNum].playerObject.transform.position = position; _players[playerNum].playerObject.transform.rotation = Quaternion.Euler(new Vector3(0, 0, rotation)); if (playerTransform.Key == _myPlayer) { Camera.main.transform.position = new Vector3(position.x, position.y, -10); } } foreach (var kvp in changes.ChangedCells) { Instantiate(_players[kvp.Value].playerTrail, new Vector2(kvp.Key.x, -kvp.Key.y), Quaternion.identity); } } } }
/// <summary> /// DR module initialization /// </summary> /// <param name="objectParameters"></param> public static void DRInit(object objectParameters) { moduleControlDataBlock = (ModuleControlDataBlock)objectParameters; threadParameters = moduleControlDataBlock.ThreadParameters; try { // Initialize Ready/Abort Event and threadpool ModuleReadyEvent = threadParameters.ModuleReadyEvent; ModuleAbortEvent = threadParameters.ModuleAbortEvent; // Set the socket configuration ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); receiveEvent = new ReceiveEvent(); ModuleReadyEvent.Set(); ReceiveWorkThread = new Thread(ReceiveWork); Log.GeneralEvent .Write("DRInit complete Phase 1 Initialization"); // Wait for core StartWork Signal ModuleStartWorkEvent = threadParameters.ModuleStartWorkEvent; ModuleStartWorkEvent.WaitOne(); Log.GeneralEvent .Write("DRInit complete Phase 2 Initialization"); ReceiveWorkThread.Start(); Log.GeneralEvent.Write("DR module is working..."); // Check ModuleAbortEvent periodically SpinWait.SpinUntil(() => !ModuleAbortEvent .WaitOne((int)TimeInterval.VeryVeryShortTime)); Log.GeneralEvent.Write("DR module is aborting."); } catch (Exception ex) { Log.ErrorEvent.Write(ex.Message); Log.ErrorEvent.Write("DR module thread failed."); threadParameters.ModuleInitFailedEvent.Set(); Log.ErrorEvent.Write("DR ModuleInitFailedEvent Set"); } CleanupExit(); }
private void StartThreadFire() { ce = new CreateEvent(1, patrons, R, R); StartFire += new ReceiveEvent(ce.Start); StopFire += new ReceiveEvent(ce.Stop); ce.CoordinatesEvent += new EventResult(FireEvent); StartFire(); Thread thread = new Thread(ce.StartCalculate); thread.Start(); StopFire2 += new ReceiveEvent(ce.Stop2); ce.CalculateEvents += new CalculationResult(Show); Thread thread2 = new Thread(ce.StartCalculateNumber); thread2.Start(); }
public ReceiveEvent GetReceivePackage(Header head, byte[] data) { if (data.Length >= (head.size + _headerLength)) { string name = System.Text.Encoding.UTF8.GetString(data, _headerLength, ReceiveEvent.Size).TrimEnd('\0'); int dataSize = (int)head.size - ReceiveEvent.Size; if (dataSize >= 0) { byte[] content = new byte[dataSize]; Buffer.BlockCopy(data, _headerLength + ReceiveEvent.Size, content, 0, dataSize); ReceiveEvent receiveEvent = new ReceiveEvent(name, content); return(receiveEvent); } } return(null); }
/// <summary> /// Sets up the notifications; /// Will call Status /// </summary> /// <param name="notifyType"></param> /// <returns>true if the notify was set up. </returns> public async Task <bool> NotifyReceiveAsync(GattClientCharacteristicConfigurationDescriptorValue notifyType = GattClientCharacteristicConfigurationDescriptorValue.Notify) { if (!await EnsureCharacteristicAsync()) { return(false); } var ch = Characteristics[4]; if (ch == null) { return(false); } GattCommunicationStatus result = GattCommunicationStatus.ProtocolError; try { result = await ch.WriteClientCharacteristicConfigurationDescriptorAsync(notifyType); if (!NotifyReceive_ValueChanged_Set) { // Only set the event callback once NotifyReceive_ValueChanged_Set = true; ch.ValueChanged += (sender, args) => { var datameaning = "STRING|ASCII^LONG|Data"; var parseResult = BluetoothDeviceController.BleEditor.ValueParser.Parse(args.CharacteristicValue, datameaning); Receive = parseResult.ValueList.GetValue("Data").AsString; ReceiveEvent?.Invoke(parseResult); }; } } catch (Exception e) { Status.ReportStatus($"NotifyReceive: {e.Message}", result); return(false); } Status.ReportStatus($"NotifyReceive: set notification", result); return(true); }
static void Main(string[] args) { Console.Write("Enter Input - send or receive \r\n"); var input = Console.ReadLine(); Console.Write("User Entered : " + input + "\r\n"); if (!String.IsNullOrEmpty(input) && input.ToLower().Equals("send")) { Console.Write("Sending \r\n"); SendEvent.SendAsync("Message ").GetAwaiter().GetResult(); } else { Console.Write("Receive \r\n"); ReceiveEvent.ReceiveAsync().GetAwaiter().GetResult(); } Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); }
void Update() { ReceiveEvent recEvent = base.Receive(); switch (recEvent.type) { case NetworkEventType.ConnectEvent: clientList.Add(recEvent.sender); break; case NetworkEventType.DataEvent: Message message = recEvent.message; if (message.type == MessageType.Move) { Direction moveDirection = (Direction)message.GetData(); _gameManager.Players[recEvent.sender].SetDirection(moveDirection); } break; case NetworkEventType.DisconnectEvent: break; } }
private void RaiseReceiveEvent(string message, IPEndPoint ipep) { ReceiveEvent?.Invoke(message, ipep); }
public async Task <ReceiveEvent> DeleteReceiveEvent(ReceiveEvent ReceiveEventInfo) { return(await _repository.UpdateAsync(ReceiveEventInfo)); }
public async Task <ReceiveEvent> CreateReceiveEvent(ReceiveEvent ReceiveEventInfo) { ReceiveEventInfo.Id = await _repository.InsertAndGetIdAsync(ReceiveEventInfo); return(ReceiveEventInfo); }
public MarshalArgs(ReceiveEvent <T> recveiveEvent, int id, T data) : this() { Event = recveiveEvent; Data = new DataSet <T>(id, data); }
protected virtual void OnReceiveEvent(MessageEventArgs e) { ReceiveEvent?.Invoke(this, e); }