public void Dispatch(BaseEvent domainEvent) { var handlerType = typeof(IHandler <>).MakeGenericType(domainEvent.GetType()); var wrapperType = typeof(DomainEventHandler <>).MakeGenericType(domainEvent.GetType()); var handlers = _container.GetServices(handlerType); var wrappedHandlers = handlers .Cast <object>() .Select(handler => (DomainEventHandler)Activator.CreateInstance(wrapperType, handler)); foreach (var handler in wrappedHandlers) { handler.Handle(domainEvent); } }
public static EventData ToEventData(BaseEvent evnt, IDictionary<string, object> headers) { var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(evnt, SerializerSettings)); var eventHeaders = new Dictionary<string, object>(headers) { { "EventClrTypeName", evnt.GetType().AssemblyQualifiedName } }; var metadata = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(eventHeaders, SerializerSettings)); var typeName = TypeToCamelcase(evnt.GetType()); return new EventData(evnt.EventId, typeName, true, data, metadata); }
public void PublishEvent(BaseEvent e) { var factory = new ConnectionFactory() { HostName = "192.168.1.5", //192.168.1.5 UserName = "******", Password = "******" }; using (var connection = factory.CreateConnection()) { using (var channel = connection.CreateModel()) { JsonSerializerSettings settings = new JsonSerializerSettings(); settings.DateFormatHandling = DateFormatHandling.IsoDateFormat; settings.NullValueHandling = NullValueHandling.Include; string message = JsonConvert.SerializeObject(e, settings); var body = Encoding.UTF8.GetBytes(message); IBasicProperties properties = channel.CreateBasicProperties(); properties.Headers = new Dictionary <string, object>(); properties.Headers.Add("EventType", e.GetType().Name); channel.BasicPublish("PostorderCompany", e.routingKey, properties, body); } } }
public static EventName GetEventName(BaseEvent inevent) { EventName result; var success = Enum.TryParse(inevent.GetType().Name, true, out result); return(success ? result : EventName.Undefined); }
public void RunCallbacks(BaseEvent ev) { if (!_registeredListeners.ContainsKey(ev.GetType())) { if (!_registeredListeners.ContainsKey(ev.GetType().BaseType)) { return; } } var registeredEvents = _registeredListeners[ev.GetType()]; foreach (var registeredEvent in registeredEvents) { registeredEvent.Call(ev); } }
static EventData GetEventData(BaseEvent evt) { var metaDataStr = JsonConvert.SerializeObject(evt.MetaData); var contentStr = JsonConvert.SerializeObject(evt); return(new EventData(Guid.NewGuid(), evt.GetType().Name, true, Encoding.UTF8.GetBytes(contentStr), Encoding.UTF8.GetBytes(metaDataStr))); }
// Raise the event to all the listeners public static void Raise(BaseEvent e) { EventDelegate del; if (Instance.delegates.TryGetValue(e.GetType(), out del)) { del.Invoke(e); } }
/// <summary> /// Call a event /// </summary> /// <param name="e">Event Type</param> public static void Raise(BaseEvent e) { Init(); EventDelegate del; _delegates.TryGetValue(e.GetType(), out del); del?.Invoke(e); }
public void Dispatch(BaseEvent e) { EventDelegate del; if (delegates.TryGetValue(e.GetType(), out del)) { del.Invoke(e); } }
/// <summary> /// Raises an event and notifies all subscribers. /// </summary> /// <param name="evt">The event parameter</param> public static void Event(BaseEvent evt) { EventDelegate del; if (dispatchDelegates.TryGetValue(evt.GetType(), out del)) { del.Invoke(evt); } }
/// <summary> /// Perform actual send /// </summary> private void Send(IDebugProcess2 process, IDebugProgram2 program, IDebugThread2 thread, BaseEvent @event) { var guid = @event.IID; DLog.Debug(DContext.VSDebuggerEvent, "DebugEngine Event {0} {1}", @event.GetType().Name, guid); var rc = callback.Event(engine, process, program, thread, @event, ref guid, (uint)@event.Attributes); if (!ErrorHandler.Succeeded(rc)) { DLog.Error(DContext.VSDebuggerEvent, "DebugEngine Event failed {0}", rc); } }
public void LogEvent(BaseEvent anEvent) { var options = EntityConverter.GetJsonSerializerOptions(); options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull; options.Converters.Add(new RemoveUserInfo()); var serializedEvent = JsonSerializer.Serialize(anEvent, anEvent.GetType(), options); _log.WithTag("Event Type", anEvent.GetEventType().ToString()).Info($"sending event: {anEvent.GetEventType()} - {serializedEvent}"); }
/// <summary> /// General EventHandler (more like an EventHub) /// </summary> public void HandleEvent(BaseEvent inEvent) { var eventType = inEvent.GetType(); var handlerList = _handlerActions[eventType]; foreach (var action in handlerList) { action.Invoke(inEvent); } }
protected async Task WriteToStream(BaseEvent evt) { await _fixture.Context.DomainEvents.AddAsync(new DomainEvent() { CreatedOn = DateTime.UtcNow, CreatedBy = "system", EventType = evt.GetType().Name, Content = JsonConvert.SerializeObject(evt) }); await _fixture.Context.SaveChangesAsync(); }
public void TriggerEvent(string eventName, BaseEvent e) { if (e == null) { Debug.Log("Invalid event argument: " + e.GetType().ToString()); return; } if (delegates.ContainsKey(eventName)) { delegates[eventName].DynamicInvoke(e); } }
private void processEvent(BaseEvent receivedEvent) { if (receivedEvent is MouseEvent) { processMouseEvent((MouseEvent)receivedEvent); } else if (receivedEvent is KeyEvent) { processKeyEvent((KeyEvent)receivedEvent); } else { throw new NotImplementedException($"Handle for event class '{receivedEvent.GetType()}' not implemented"); } }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { BaseEvent e = value as BaseEvent; if (e == null) { return(Visibility.Collapsed); } if (e.GetType() != typeof(KillEvent) && Settings.Default.LogOnlyKillOnOverview) { return(Visibility.Collapsed); } return(Visibility.Visible); }
private static void OnLuaEvent(BaseEvent Event) { if (!EventList_.ContainsKey(Event.EventName)) { return; } var Properties = Event.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); var Table = LuaEnv_.NewTable(); foreach (var Property in Properties) { Table.SetInPath(Property.Name, Property.GetValue(Event)); } foreach (var Evt in EventList_[Event.EventName]) { Evt.Value.Invoke(Evt.Key, Table); } }
private static void FireWmiEventCore(BaseEvent baseEvent) { try { baseEvent.Fire(); } catch (Exception exp) { string msg = SR.WmiEventFailure(baseEvent.GetType().Name, GetErrorMessage(exp)); COMException comException = exp as COMException; if (null != comException) { if ((uint)comException.ErrorCode == WbemAccessDenied) { msg = string.Concat(SR.ExceptionAccessDeniedFailure, msg); } } ReportWmiFailure(msg); } }
public IEnumerable <BaseEventHandler> GetEventHandlersOrDefault(BaseEvent eventPayload) { var type = eventPayload.GetType(); var handlers = new List <BaseEventHandler>(); foreach (var eventHandler in eventHandlers) { if (eventHandler.CanHandleEvent(type)) { handlers.Add(eventHandler); } } if (handlers.Count == 0) { handlers.Add(new DefaultHandler()); } return(handlers); }
public override async Task <string> HandleEvent( APIGatewayProxyRequest request, ILambdaContext context, string deliveryId, BaseEvent eventPayload) { if (eventPayload is T tPayload) { return(await HandleEvent(request, context, deliveryId, tPayload)); } else { throw new ArgumentException( $"EventHandler expects payload of type '{typeof(T)}', received type '{eventPayload.GetType()}'", nameof(eventPayload)); } }
public void LogEvent(BaseEvent anEvent) { var serializedEvent = JsonSerializer.Serialize(anEvent, anEvent.GetType(), _options); _log.WithTag("Event Type", anEvent.GetEventType().ToString()).Info($"sending event: {anEvent.GetEventType()} - {serializedEvent}"); }
public static void TraceBaseEvent(BaseEvent eEvent) { Debug.Log("----------------------trace BaseEvent-----------------------------:" + eEvent.GetType()); IDictionaryEnumerator a = eEvent.Params.GetEnumerator(); while (a.MoveNext()) { Debug.Log("key:" + a.Key); SFSObject o = a.Value as SFSObject; Debug.Log(o != null ? o.GetDump() : a.Value); } Debug.Log("=====================trace BaseEvent end==========================="); }
public async Task <AggregateApplicationResult> ApplyEventAsync(BaseEvent evt) { // Lets have a constraint for item Name uniqueness ItemAggregate aggregate; BaseItemEvent itemEvent; switch (evt) { case ItemCreatedEvent created: var itemsWithSameName = await aggregatesRepository.GetByNameAsync(created.Name); if (itemsWithSameName.Any(x => x.LastEvent != null && !(x.LastEvent is ItemDeletedEvent))) { return(new ItemAlreadyExistsApplicationResult("Item with the same name already exists")); } aggregate = new ItemAggregate(created.ItemId); itemEvent = created; break; case ItemDeletedEvent deleted: aggregate = await aggregatesRepository.GetByIdAsync(deleted.ItemId); if (aggregate == null || aggregate.LastEvent == null) { return(new ItemNotFoundApplicationResult()); } if (aggregate.LastEvent is ItemDeletedEvent) { // It is already deleted return(new SuccessAggregateApplicationResult()); } itemEvent = deleted; break; case ItemUpdatedEvent updated: aggregate = await aggregatesRepository.GetByIdAsync(updated.ItemId); if (aggregate == null || aggregate.LastEvent == null || aggregate.LastEvent is ItemDeletedEvent) { return(new ItemNotFoundApplicationResult()); } if (aggregate.LastEvent is ItemUpdatedEvent lastUpdated && lastUpdated.Name.Equals(updated.Name)) { // This aggregate has already got this name return(new SuccessAggregateApplicationResult()); } // Looking for another aggregate with this name var itemsWithSameNameForUpdate = await aggregatesRepository.GetByNameAsync(updated.Name); if (itemsWithSameNameForUpdate.Any(x => x.LastEvent != null && !(x.LastEvent is ItemDeletedEvent))) { return(new ItemAlreadyExistsApplicationResult("Item with the same name already exists")); } itemEvent = updated; break; default: return(new FailedAggregateApplicationResult($"Specified event type {evt.GetType().Name} is not supported")); } var applicationResult = aggregate.ApplyEvent(itemEvent); switch (applicationResult) { case SuccessAggregateApplicationResult success: // This method might be a root specific, because of several aggregate repositories might be impacted by one event this.stagedAggregates.Add(aggregate); break; } return(applicationResult); }
private async Task SendEvent(BaseEvent @event) { _messageSession = (IMessageSession)_serviceProvider.GetService(typeof(IMessageSession)); await _messageSession.Publish(@event); _logger.LogInformation("----- Published {IntegrationEventName}: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", @event.GetType().Name, @event.Id, Program.AppName, @event); }
/// <summary> /// Send the given event to all event sinks /// </summary> private void SendEvent(IDebugCoreServer2 server, IDebugPort2 port, IDebugProcess2 process, IDebugProgram2 program, BaseEvent @event) { var iid = @event.IID; DLog.Debug(DContext.VSDebuggerEvent, "DebugPort Event {0} {1}", @event.GetType().Name, iid); foreach (var eventSink in eventSinks) { var events = eventSink as IDebugPortEvents2; if (events != null) { var rc = events.Event(server, port, process, program, @event, ref iid); if (!ErrorHandler.Succeeded(rc)) { DLog.Error(DContext.VSDebuggerEvent, "DebugPort Event failed {0}", rc); } } } }