public void OnError(Exception exception, IEventMessage @event, IEventListener eventListener) { var eventListenerType = eventListener is IEventListenerProxy ? ((IEventListenerProxy)eventListener).TargetType : eventListener.GetType(); _logger.LogError($"EventListener [{eventListenerType.Name}] failed to handle event [{@event.Identifier}] ({@event.PayloadType}). " + "Continuing processing with next listener", exception); }
public static IEnumerable <IEventMessage <DomainAggregateEvent> > Upgrade <TSource>( this IEventMessage <TSource> oldMessage, params DomainAggregateEvent[] newEvents) where TSource : DomainAggregateEvent { return(newEvents.Select(newEvent => (IEventMessage <DomainAggregateEvent>)UpgradedEventMessage.Create(oldMessage, newEvent))); }
public void SendAndReceiveWithTopicsCorrectly() { //Arrange IEventMessage receivedMessage = null; AutoResetEvent flag = new AutoResetEvent(false); var sender = _context.CreateMessageSender(); var receiver = _context.CreateMessageReceiver("TestQueue", new List <string>() { "test" }); receiver.DeclareQueue(); var message = new EventMessage("test", "TestMessage"); //Act sender.SendMessage(message); receiver.StartReceivingMessages(eventMessage => { receivedMessage = eventMessage; flag.Set(); }); flag.WaitOne(); //Assert Assert.IsNotNull(receivedMessage); Assert.AreEqual("TestMessage", receivedMessage.Message); }
protected override string OnInitState(IEventMessage message) { var eventMessage = TypeCast(message); if (eventMessage == null) return StateType.INIT; var agentSession = new AgentSession(eventMessage.Handler) { ConferenceId = eventMessage.ConferenceId, AgentName = eventMessage.AgentName, PublisherUrl = eventMessage.PresentationUrl, EndpointAddress = eventMessage.EndpointAddress, IsPublisher = true }; sessionContext.Register(agentSession); agentSession.Process(new ResponseEvent { AgentName = sessionContext.SessionOfAgent.AgentName, ConferenceId = sessionContext.SessionOfAgent.ConferenceId, PresentationUrl = eventMessage.PresentationUrl, SessionId = sessionContext.SessionId, ResponseStatus = ResponseStatus.Ok }); return StateType.READY; }
public Review OnReview( Episode episode, IEventMessage message, [Service] IReviewRepository _repository) { return((Review)message.Payload); }
public void Send(IEventMessage message) { var eventBuilder = EventBuilder.Build(message); var data = eventBuilder.ToByteArray(); this.Client.Send(data, data.Length); }
/// <summary> /// RunTask /// </summary> /// <param name="transfer"></param> private void RunTask(IEventMessage transfer) { String eventMessage = transfer.EventMessage; //事件消息 KeyValuePair<string, string> taskEventPair = new KeyValuePair<string, string>(Status, eventMessage);//事件-传输子对 //判断是否存在任务,如果不存在任务的话,保持现状 if (_tTaskTable.ContainsKey(taskEventPair)) { //根据事件-传输子对取得一个任务 StateMachineTask stateMachineTask = _tTaskTable[taskEventPair]; //判断任务是否存在 if (stateMachineTask != null) { //判断任务中是否有下一个状态 if (stateMachineTask.NextStatus != null) { //设定下一个状态 Status = stateMachineTask.NextStatus; } //判断动作是否存在 if (stateMachineTask.Action != null) { //载入传输子,执行动作 stateMachineTask.Action(transfer); } } } }
public void Publish(IEventMessage <object> msg, TParent declaringInstance) { var targetList = _eventTargetResolver(msg, declaringInstance); targetList.GetRange(0, targetList.Count) // Creates copy to prevent ConcurrentModificationException. .ForEach(target => _entityModel.Publish(msg, target)); }
public async Task SetCheckpointAsync(IEventMessage eventArgs, IEnumerable <KeyValuePair <Metric, double> > metrics = null) { EnsureArg.IsNotNull(eventArgs); EnsureArg.IsNotNullOrWhiteSpace(eventArgs.PartitionId); try { var partitionId = eventArgs.PartitionId; var checkpoint = new Checkpoint { LastProcessed = eventArgs.EnqueuedTime, Id = partitionId, Prefix = _blobPath, }; await UpdateCheckpointAsync(checkpoint); _logger.LogMetric(EventMetrics.EventWatermark(partitionId), 1); if (metrics != null) { foreach (var metric in metrics) { _logger.LogMetric(metric.Key, metric.Value); } } } catch (Exception ex) { _logger.LogError(new StorageCheckpointClientException($"Unable to set checkpoint. {ex.Message}", ex)); } }
/// <summary> /// 实时广播事件 /// </summary> public void SendMessage(int eventId, IEventMessage message) { if (_listeners.ContainsKey(eventId) == false) { return; } LinkedList <Action <IEventMessage> > listeners = _listeners[eventId]; if (listeners.Count > 0) { var currentNode = listeners.Last; while (currentNode != null) { currentNode.Value.Invoke(message); currentNode = currentNode.Previous; } } // 回收引用对象 IReference refClass = message as IReference; if (refClass != null) { ReferencePool.Release(refClass); } }
protected void TestEventMessageProperties <T>(AssertHelper assertHelper, IEventMessage <T> message, long timestamp, int productId, string eventId, long?requestId) where T : class, ISportEvent { TestMessageProperties(assertHelper, message, timestamp, productId); assertHelper.IsNotNull(() => message.Event); assertHelper.AreEqual(() => message.Event.Id.ToString(), eventId); assertHelper.AreEqual(() => message.RequestId, requestId); }
/// <summary> /// 事件处理 /// </summary> private void OnHandleEventMessage(IEventMessage msg) { if (msg is PatchEventMessageDefine.PatchStatesChange) { var message = msg as PatchEventMessageDefine.PatchStatesChange; // 初始化结束 if (message.CurrentStates == EPatchStates.InitiationOver) { PatchWindow.Instance.Initialize(); } // 补丁下载完毕 // 注意:在补丁下载结束之后,一定要强制释放资源管理器里所有的资源,还有重新载入Unity清单。 if (message.CurrentStates == EPatchStates.DownloadOver) { PatchWindow.Instance.Destroy(); ResourceManager.Instance.ForceReleaseAll(); PatchManager.Instance.ReloadUnityManifest(); // 开始游戏 StartGame(); } } else if (msg is PatchEventMessageDefine.OperationEvent) { PatchManager.Instance.HandleEventMessage(msg); } }
private bool SubmitMessage(IEventMessage message) { try { if (_messageQueue.TryAdd(message)) { _inputCapacityExceeded.GetAndSet(false); } else { // This doesn't mean that the output event buffer is full, but rather that the main thread is // seriously backed up with not-yet-processed events. We shouldn't see this. if (!_inputCapacityExceeded.GetAndSet(true)) { Log.Warn("Events are being produced faster than they can be processed"); } } } catch (InvalidOperationException) { // queue has been shut down return(false); } return(true); }
/// <summary> /// Write an event message to Microsoft SQL Server. /// </summary> /// <param name="message">EventMessage</param> public virtual void Write(IEventMessage message) { if (_connection.State == ConnectionState.Closed) { _connection.Open(); } using (SqlCommand command = new SqlCommand()) { command.Connection = _connection; #pragma warning disable CA2100 // Cannot use parameter for table name. Tablename is already checked in the CreateTable method. command.CommandText = "INSERT INTO [" + _tableName + "]([EventType],[TimeStamp],[Source],[Content],[Application]) VALUES (@EventType,@TimeStamp,@Source,@Content,@Application)"; #pragma warning disable CA2100 // Cannot use parameter for table name. Tablename is already checked in the CreateTable method. command.Parameters.Add("EventType", SqlDbType.SmallInt).Value = (short)message.Level; //command.Parameters.Add("Host", SqlDbType.VarChar, 255).Value = message.Host; command.Parameters.Add("TimeStamp", SqlDbType.DateTime).Value = message.TimeStamp; command.Parameters.Add("Source", SqlDbType.VarChar, 255).Value = message.Source; command.Parameters.Add("Content", SqlDbType.VarChar).Value = message.Content; command.Parameters.Add("Application", SqlDbType.VarChar, 255).Value = _application; if (command.ExecuteNonQuery() != 1) { throw new Exception("BlackBox.Write : Error writing to black box database table"); } } if (!_keepConnectionOpen) { _connection.Close(); } }
/// <summary> /// Write an event message to Microsoft SQL Server. /// </summary> /// <param name="message">EventMessage</param> public virtual void Write(IEventMessage message) { if (_connection.State == ConnectionState.Closed) { _connection.Open(); } using (IDbCommand command = _connection.CreateCommand()) { command.Connection = _connection; #pragma warning disable CA2100 // Cannot use parameter for table name. Tablename is already checked in the CreateTable method. command.CommandText = "INSERT INTO [" + _tableName + "]([EventType],[TimeStamp],[Source],[Content],[Application]) VALUES (@EventType,@TimeStamp,@Source,@Content,@Application)"; #pragma warning disable CA2100 // Cannot use parameter for table name. Tablename is already checked in the CreateTable method. command.AddParameter("EventType", (short)message.Level); command.AddParameter("TimeStamp", message.TimeStamp); command.AddParameter("Source", message.Source, 255); command.AddParameter("Content", message.Content); command.AddParameter("Application", _application, 255); if (command.ExecuteNonQuery() != 1) { throw new Exception("BlackBox.Write : Error writing to black box data store table"); } } if (!_keepConnectionOpen) { _connection.Close(); } }
public Task SubscribeTwoConsumer_SendOneMessage_BothConsumerReceivesMessage() { return(TryTest(async() => { // arrange var cts = new CancellationTokenSource(30000); var eventDescription = new EventDescription( Guid.NewGuid().ToString()); // act IEventStream consumerOne = await _registry .SubscribeAsync(eventDescription); IEventStream consumerTwo = await _registry .SubscribeAsync(eventDescription); var outgoing = new EventMessage(eventDescription, "bar"); await _sender.SendAsync(outgoing); // assert IEventMessage incomingOne = await consumerOne.ReadAsync(cts.Token); IEventMessage incomingTwo = await consumerTwo.ReadAsync(cts.Token); Assert.Equal(outgoing.Payload, incomingOne.Payload); Assert.Equal(outgoing.Payload, incomingTwo.Payload); })); }
private void WriteMessageData(IOddsFeedSession session, IEventMessage <ISportEvent> message, DateTime messageUserReceived = default, double processingTotalMilliSeconds = 0) { var userStartProcessing = DateTime.Now; var sdkProcessingTime = (userStartProcessing - Helper.FromEpochTime(message.Timestamps.Received)).TotalMilliseconds; var createdToUserTime = (userStartProcessing - Helper.FromEpochTime(message.Timestamps.Created)).TotalMilliseconds; var pureSdkTime = messageUserReceived == default ? sdkProcessingTime : (userStartProcessing - messageUserReceived).TotalMilliseconds; var messageName = message.GetType().Name; messageName = messageName.Substring(0, messageName.IndexOf("`", StringComparison.InvariantCultureIgnoreCase)); var requestId = message.RequestId.HasValue ? $", RequestId={message.RequestId}" : string.Empty; var producerMessage = $"[{message.Producer.Id}-{message.Producer.Name}|{Helper.ToEpochTime(message.Producer.LastTimestampBeforeDisconnect)}={message.Producer.LastTimestampBeforeDisconnect}|{!message.Producer.IsProducerDown}]"; var processingTotalMilliSecondsStr = processingTotalMilliSeconds > 0 ? $", COMPLETED in {processingTotalMilliSeconds}ms" : string.Empty; var msg = $"{session.Name}: {messageName}:Producer={producerMessage}, GeneratedAt={message.Timestamps.Created}={Helper.FromEpochTime(message.Timestamps.Created)}, PureSdkProcessingTime={(int)pureSdkTime}ms, SdkProcessingTime={(int)sdkProcessingTime}ms, Behind={(int)createdToUserTime}ms, EventId={message.Event.Id}{requestId}{processingTotalMilliSecondsStr}."; Helper.WriteToOutput(msg); _log.LogInformation(msg); if (message.Timestamps.Sent == 0) { msg = $"Message {messageName} created {message.Timestamps.Created} on producer {message.Producer.Id}-{message.Producer.Name} does not have sent timestamp."; Helper.WriteToOutput(msg); _log.LogError(msg); } }
protected override IEnumerable <object> ResolveEventTargets(IEventMessage message, object parentEntity, PropertyInfo field, IForwardingMode eventForwardingMode) { var fieldValue = field.GetValue(parentEntity); var valuesCollection = field.GetType().GetProperty(nameof(IDictionary.Values))?.GetValue(fieldValue) as IEnumerable; return(valuesCollection == null?Enumerable.Empty <object>() : eventForwardingMode.FilterCandidates(message, valuesCollection.Cast <object>())); }
private void OnHandleEvent(IEventMessage msg) { if (msg is LoginEvent.ConnectServer) { FsmManager.Instance.Transition(nameof(NodeTown)); } }
public bool Equals(IEventMessage other) { return(Id.Equals(other.Id) && EventType == other.EventType && Message == other.Message && CreatedDate.Equals(other.CreatedDate)); }
public bool TryProcessMessage(IEventMessage message, IMessageParameters parameters, TPeerType peer) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (peer == null) { throw new ArgumentNullException(nameof(peer)); } TPayloadType payload = message.Payload.Data as TPayloadType; //if it's the not the payload type this handler handles then we //indicate non-consumption if (payload == null) { return(false); } else { OnIncomingHandlableMessage(message, payload, parameters, peer); } //If an exception wasn't thrown we'll be indicating that the payload has been consumed. return(true); }
public IEvent <TKey, TAggregate> ToEvent <TKey, TAggregate>(IEventMessage eventMessage) where TAggregate : IAggregate <TKey> { var @event = (IEvent <TKey, TAggregate>)Serializer.Deserialize(eventMessage.ProducerMessage.MessageBytes, eventMessage.ProducerMessage.MessageType); @event.Version = eventMessage.EventId.Version; return(@event); }
///// <summary> ///// Checks if there is at least one writer which logs on given event level. ///// </summary> ///// <param name="level">Event level to check.</param> ///// <returns>True is there is at least one writer that writers at given level.</returns> //public virtual bool InEnabled(EventLevel level) //{ // if (level == EventLevel.Debug && !Debugger.IsAttached) return false; // for (int i = 0; i < _writers.Count; i++) // { // if (_writers[i].Level < level) return false; // } // return true; //} /// <summary> /// Write event message. Use fallback event writer when primairy writer throws an exception. This write method blocks until the writer is finished. /// </summary> /// <param name="message">Event message to write</param> public virtual void Write(IEventMessage message) { if (message == null) { return; } if (message.Level == EventLevel.Debug && !Debugger.IsAttached) { return; } for (int i = 0; i < _writers.Count; i++) { if (_writers[i].Level < message.Level) { continue; } try { _writers[i].Write(message); } catch (Exception exception) { if (_writerFallBack != null) { try { _writerFallBack.Write(message); _writerFallBack.Write(exception.ToMessage()); } catch { } } } } }
public async Task SetCheckpointAsync(IEventMessage eventArgs) { EnsureArg.IsNotNull(eventArgs); EnsureArg.IsNotNullOrWhiteSpace(eventArgs.PartitionId); try { var partitionId = eventArgs.PartitionId; var checkpoint = new Checkpoint(); checkpoint.LastProcessed = eventArgs.EnqueuedTime; checkpoint.Id = partitionId; checkpoint.Prefix = _blobPath; _checkpoints[partitionId] = checkpoint; var count = _lastCheckpointTracker.AddOrUpdate(partitionId, 1, (key, value) => value + 1); if (count >= _lastCheckpointMaxCount) { await PublishCheckpointAsync(partitionId); _log.LogMetric(EventMetrics.EventWatermark(partitionId, eventArgs.EnqueuedTime.UtcDateTime), 1); _lastCheckpointTracker[partitionId] = 0; } } #pragma warning disable CA1031 catch (Exception ex) #pragma warning restore CA1031 { _log.LogError(new Exception($"Unable to set checkpoint. {ex.Message}")); } }
public void StartReceivingMessages_InvokesCallbackWithCorrectEventMessage() { // Arrange var channelMock = new Mock <IModel>(); AsyncEventingBasicConsumer basicConsumer = null; channelMock.Setup(c => c.BasicConsume("TestQueue", true, "", false, false, null, It.IsAny <AsyncEventingBasicConsumer>())) .Callback((string queue, bool autoAck, string consumerTag, bool noLocal, bool exclusive, IDictionary <string, object> arguments, IBasicConsumer consumer) => { basicConsumer = consumer as AsyncEventingBasicConsumer; }); var connectionMock = new Mock <IConnection>(); connectionMock.Setup(c => c.CreateModel()) .Returns(channelMock.Object); var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange"); var receiver = new RabbitMQMessageReceiver(context, "TestQueue", new List <string> { "TestTopic2" }); // Act bool callbackWasInvoked = false; IEventMessage eventMessage = null; receiver.StartReceivingMessages((e) => { callbackWasInvoked = true; eventMessage = e; }); var properties = new BasicProperties { Type = "Test type", Timestamp = new AmqpTimestamp(1542183431), CorrelationId = "test id" }; basicConsumer.HandleBasicDeliver("", 0, false, "", "routing.key", properties, Encoding.UTF8.GetBytes("test message")).Wait(); // Assert Assert.IsTrue(callbackWasInvoked); Assert.AreEqual("routing.key", eventMessage.RoutingKey); Assert.AreEqual("test message", eventMessage.Message); Assert.AreEqual("Test type", eventMessage.EventType); Assert.AreEqual(1542183431, eventMessage.Timestamp); Assert.AreEqual("test id", eventMessage.CorrelationId); }
public void Publish(IEventMessage message, object target) { if (target != null) { RuntimeModelOf(target).DoPublish(message, target); } }
public GenericObject OnData( int sensorId, IEventMessage message, //[Service] IUploadDataRepository _repository [Service] ITimeSeriesRepository _repository ) { var data = (CreatedDataValues)message.Payload; List <(int, string)> sensorNameIdPairs = _repository.GetSensorTablePair(new List <int>() { data.sensorId }); var queryString = ""; foreach (var sensorNameIdPair in sensorNameIdPairs) { queryString = queryString + TimeSeriesQueryBuilder.CreateTimeSeriesQueryString( sensorNameIdPair.Item1, sensorNameIdPair.Item2, data.fromDate, data.toDate ); } return(_repository.GetTimeSeries("", queryString).Result); }
/// <summary> /// RunTask /// </summary> /// <param name="transfer"></param> private void RunTask(IEventMessage transfer) { String eventMessage = transfer.EventMessage; //事件消息 KeyValuePair <string, string> taskEventPair = new KeyValuePair <string, string>(Status, eventMessage); //事件-传输子对 //判断是否存在任务,如果不存在任务的话,保持现状 if (_tTaskTable.ContainsKey(taskEventPair)) { //根据事件-传输子对取得一个任务 StateMachineTask stateMachineTask = _tTaskTable[taskEventPair]; //判断任务是否存在 if (stateMachineTask != null) { //判断任务中是否有下一个状态 if (stateMachineTask.NextStatus != null) { //设定下一个状态 Status = stateMachineTask.NextStatus; } //判断动作是否存在 if (stateMachineTask.Action != null) { //载入传输子,执行动作 stateMachineTask.Action(transfer); } } } }
/// <summary> /// Write an event message to the console. /// </summary> /// <param name="message"></param> public virtual void Write(IEventMessage message) { ConsoleColor tempForegroundColor = Console.ForegroundColor; ConsoleColor tempBackgroudnColor = Console.BackgroundColor; Console.BackgroundColor = ConsoleColor.Black; switch (message.Level) { case EventLevel.Critical: Console.ForegroundColor = ConsoleColor.Magenta; break; case EventLevel.Debug: Console.ForegroundColor = ConsoleColor.DarkGreen; break; case EventLevel.Error: Console.ForegroundColor = ConsoleColor.Red; break; case EventLevel.Trace: Console.ForegroundColor = ConsoleColor.Gray; break; case EventLevel.Warning: Console.ForegroundColor = ConsoleColor.DarkMagenta; break; case EventLevel.Info: Console.ForegroundColor = ConsoleColor.Gray; break; default: Console.ForegroundColor = ConsoleColor.Gray; break; } Console.WriteLine(FormatMessage(message)); Console.ForegroundColor = tempForegroundColor; Console.BackgroundColor = tempBackgroudnColor; }
public Task SubscribeTwoConsumer_SendTwoMessage_BothConsumerReceivesIndependentMessage() { return(TryTest(async() => { // arrange var cts = new CancellationTokenSource(30000); string name = Guid.NewGuid().ToString(); var eventDescriptionOne = new EventDescription( name, new ArgumentNode("b", "x")); var eventDescriptionTwo = new EventDescription( name, new ArgumentNode("b", "y")); // act IEventStream consumerOne = await _registry .SubscribeAsync(eventDescriptionOne); var outgoingOne = new EventMessage(eventDescriptionOne, "foo"); await _sender.SendAsync(outgoingOne); IEventStream consumerTwo = await _registry .SubscribeAsync(eventDescriptionTwo); var outgoingTwo = new EventMessage(eventDescriptionTwo, "bar"); await _sender.SendAsync(outgoingTwo); // assert IEventMessage incomingOne = await consumerOne.ReadAsync(cts.Token); IEventMessage incomingTwo = await consumerTwo.ReadAsync(cts.Token); Assert.Equal(outgoingOne.Payload, incomingOne.Payload); Assert.Equal(outgoingTwo.Payload, incomingTwo.Payload); Assert.NotEqual(incomingOne.Event, incomingTwo.Event); })); }
protected override void OnHandleEvent(IEventMessage msg) { if (msg is BattleEvent.DamageHurt) { if (CharData.IsDead == false) { BattleEvent.DamageHurt message = msg as BattleEvent.DamageHurt; CharData.DamageHurt(message.Damage); CharAnim.Play("getHit"); // 随机播放角色受击音效 string soundName = Avatar.GetRandomGetHitSound(); if (string.IsNullOrEmpty(soundName) == false) { AudioManager.Instance.PlaySound(soundName); } } } else if (msg is BattleEvent.CharacterDead) { CharSkill.ForbidAll(); CharAnim.Play("die"); // 播放角色死亡音效 string soundName = Avatar.GetDeadSound(); if (string.IsNullOrEmpty(soundName) == false) { AudioManager.Instance.PlaySound(soundName); } } }
public string BuildMessage(IEvent @event) { IEventMessage builder = _builders[@event.EventType]; string message = builder == null ? "<UNKNOWN_EVENT_TYPE>" : builder.BuildMessage(@event); return(message); }
protected override string OnReadyState(IEventMessage message) { sessionContext.ResponseTimeoutContext.StopWatchObj.Stop(); var eventMessage = TypeCast(message); if (eventMessage == null) return StateType.READY; var agentSession = sessionContext.GetPublisherSession(eventMessage.PresentationUrl); agentSession.Process(eventMessage); return StateType.READY; }
protected override string OnReadyState(IEventMessage message) { var eventMessage = TypeCast(message); if (eventMessage == null) return StateType.READY; var agentSession = sessionContext.GetPublisherSession(eventMessage.PresentationUrl); agentSession.Process(eventMessage); sessionContext.SessionOfAgent.Process(new ResponseEvent { AgentName = sessionContext.SessionOfAgent.AgentName, ConferenceId = sessionContext.SessionOfAgent.ConferenceId, PresentationUrl = eventMessage.PresentationUrl, SessionId = sessionContext.SessionId, ResponseStatus = ResponseStatus.Continue }); sessionContext.ResponseTimeoutContext.StopWatchObj.Start(); return StateType.PLAYING; }
protected virtual string OnInitState(IEventMessage message) { return StateType.INIT; }
protected virtual string OnReadyState(IEventMessage message) { return StateType.READY; }
protected virtual string OnPlayingState(IEventMessage message) { return StateType.PLAYING; }
public Event(string name, IEventMessage message) { this.name = name; this.message = message; }
/// <summary> /// Deserialize the message /// </summary> /// <param name="map">An <see cref="OSDMap"/> containing the data</param> public void Deserialize(OSDMap map) { if (map.ContainsKey("ack")) Messages = new EventQueueAck(); else if (map.ContainsKey("events")) Messages = new EventQueueEvent(); else Logger.Log("Unable to deserialize EventQueueGetMessage: No message handler exists for event", Helpers.LogLevel.Warning); Messages.Deserialize(map); }
public async Task Publish(IEventMessage message) { var topicClient = TopicClient.CreateFromConnectionString(_connectionString, message.GetType().FullName); await topicClient.SendAsync(BuildBrokeredMessage(message)); }
private PlayEvent TypeCast(IEventMessage message) { return message is PlayEvent ? message as PlayEvent : null; }
protected override string OnInitState(IEventMessage message) { sessionContext.UnRegister(); return StateType.END; }
protected override string OnReadyState(IEventMessage message) { return StateType.END; }
public void Send(IEventMessage message) { subscriber.Handle(message); }
private ResponseEvent TypeCast(IEventMessage message) { return message is ResponseEvent ? message as ResponseEvent : null; }
/// <summary> /// Interface method overload for receiving a <see cref="IEventMessage"/>. /// </summary> /// <param name="message">The event recieved from the remote peer.</param> /// <param name="parameters">The message parameters the message was sent with.</param> public void OnNetworkMessageReceive(IEventMessage message, IMessageParameters parameters) { Throw<ArgumentNullException>.If.IsNull(message)?.Now(nameof(message)); EventPublisher?.Invoke(message, parameters); }
private AnnounceEvent TypeCast(IEventMessage message) { return message is AnnounceEvent ? message as AnnounceEvent : null; }
protected override string OnInitState(IEventMessage message) { throw new RuleException(); }
public string Action(IEventMessage message, string currentState) { Func<IEventMessage, string> handler; return !actionPool.TryGetValue(currentState, out handler) ? currentState : handler(message); }
private TimeOutEvent TypeCast(IEventMessage message) { return message is TearDownEvent ? message as TimeOutEvent : null; }
public static void Send(IEventMessage eventMessage) { Instance.Send(eventMessage); }
/// <summary> /// 同步触发器 /// </summary> /// <param name="transfer"></param> public void SyncTrigger(IEventMessage transfer) { //执行任务 RunTask(transfer); }
public Task Publish(IEventMessage message) { return _sender.Publish(message); }
public Task Publish(IEventMessage message) { _messages.OnNext(message); return Task.FromResult(true); }