public bool Publish <TEvent>(TEvent @event) where TEvent : class, IEventBase
{
var handlers = _eventHandlerFactory.GetHandlers <TEvent>();
if (handlers.Count > 0)
{
var handlerTasks = new Task[handlers.Count];
handlers.ForEach((handler, index) =>
{
handlerTasks[index] = handler.Handle(@event).ContinueWith(r =>
{
if (r.IsFaulted)
{
_logger.Error(r.Exception?.Unwrap(),
$"handle event [{typeof(TEvent).FullName}] error, eventHandlerType:{handler.GetType().FullName}");
}
});
});
_ = handlerTasks.WhenAll().ConfigureAwait(false);
return(true);
}
return(false);
}
public async Task Publish <T>(T @event) where T : Event
{
var handlers = _eventHandlerFactory.GetHandlers <T>();
var eventHandlers = new List <Task>();
foreach (var eventHandler in handlers)
{
eventHandlers.Add(eventHandler.Handle(@event));
}
await Task.WhenAll(eventHandlers);
}
public async Task UserCategoriesFromHistoryCanPopulateQueryDb()
{
await _aggregateRepository.Create(new AggregateRoot { EventVersion = 0, Version = 0, Id = 1 });
UserCategoryCreatedEvent e2 = new UserCategoryCreatedEvent(1, "Category 1", DateTime.UtcNow);
await _eventRepository.Create(new Event { Id = 2, AggregateId = 1, Data = DatabaseEventStorage.Serialize <UserCategoryCreatedEvent>(e2) });
UserCategoryNameChangedEvent e3 = new UserCategoryNameChangedEvent(1, "Category 1 Renamed Once", 0, DateTime.UtcNow);
await _eventRepository.Create(new Event { Id = 3, AggregateId = 1, Data = DatabaseEventStorage.Serialize <UserCategoryNameChangedEvent>(e3) });
UserCategoryNameChangedEvent e4 = new UserCategoryNameChangedEvent(1, "Category 1 Renamed Twice", 1, DateTime.UtcNow);
await _eventRepository.Create(new Event { Id = 4, AggregateId = 1, Data = DatabaseEventStorage.Serialize <UserCategoryNameChangedEvent>(e4) });
UserCategoryNameChangedEvent e5 = new UserCategoryNameChangedEvent(1, "Category 1 Renamed Three Times", 2, DateTime.UtcNow);
await _eventRepository.Create(new Event { Id = 5, AggregateId = 1, Data = DatabaseEventStorage.Serialize <UserCategoryNameChangedEvent>(e5) });
UserCategoryNameChangedEvent e6 = new UserCategoryNameChangedEvent(1, "Category 1 Renamed Four Times", 3, DateTime.UtcNow);
await _eventRepository.Create(new Event { Id = 6, AggregateId = 1, Data = DatabaseEventStorage.Serialize <UserCategoryNameChangedEvent>(e6) });
UserCategoryNameChangedEvent e7 = new UserCategoryNameChangedEvent(1, "Category 1 Renamed Five Times", 4, DateTime.UtcNow);
await _eventRepository.Create(new Event { Id = 7, AggregateId = 1, Data = DatabaseEventStorage.Serialize <UserCategoryNameChangedEvent>(e7) });
foreach (var @event in (await _eventRepository.FindByAsync(x => true)).ToList())
{
var e = DatabaseEventStorage.DeSerialize(@event.Data);
if (e is UserCategoryNameChangedEvent)
{
var handlers = _eventHandlerFactory.GetHandlers <UserCategoryNameChangedEvent>();
foreach (var eventHandler in handlers)
{
eventHandler.Handle(e);
}
}
if (e is UserCategoryCreatedEvent)
{
var handlers = _eventHandlerFactory.GetHandlers <UserCategoryCreatedEvent>();
foreach (var eventHandler in handlers)
{
eventHandler.Handle(e);
}
}
}
var cats = await _categoryRepo.FindByAsync(q => q.Id == 1).ConfigureAwait(false);
var cat = cats.FirstOrDefault();
Assert.AreEqual("Category 1 Renamed Five Times", cat.Name);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
var queues = await _eventQueue.GetQueuesAsync();
if (queues.Count > 0)
{
await queues.Select(async q =>
{
var @event = await _eventQueue.DequeueAsync(q);
if (null != @event)
{
var handlers = _eventHandlerFactory.GetHandlers(@event.GetType());
if (handlers.Count > 0)
{
await handlers
.Select(h => h.Handle(@event))
.WhenAll()
;
}
}
})
.WhenAll()
;
}
await Task.Delay(1000, stoppingToken);
}
}
public static ICollection <IEventHandler <TEvent> > GetHandlers <TEvent>(this IEventHandlerFactory eventHandlerFactory)
where TEvent : class, IEventBase
{
return(eventHandlerFactory.GetHandlers(typeof(TEvent))
.Cast <IEventHandler <TEvent> >()
.ToArray());
}
public void Invoke <T>(T @event) where T : IEvent
{
var handlers = _eventHandlerFactory.GetHandlers <T>();
if (handlers != null)
{
_busLogger.Received(@event);
foreach (var handler in handlers)
{
try
{
// handle event in current thread
handler.Handle(@event);
}
catch (ACE.Exceptions.BusinessException)
{
}
catch (Exception ex)
{
_busLogger.Exception(@event, ex);
throw;
}
}
}
}
private void DistributeInThreadPool <T>(T @event) where T : IEvent
{
if (_eventHandlerFactory == null)
{
return;
}
var handlers = _eventHandlerFactory.GetHandlers <T>();
if (handlers != null)
{
_busLogger.Received(@event);
foreach (var handler in handlers)
{
Task.Factory.StartNew(() =>
{
try
{
handler.Handle(@event);
}
catch (Exception ex)
{
_busLogger.Exception(@event, ex);
}
});
}
}
}
public void Publish <T>(T @event) where T : Event
{
var handlers = _eventHandlerFactory.GetHandlers <T>();
foreach (var eventHandler in handlers)
{
eventHandler.Handle(@event);
}
}
private async Task PublishEventAsync <TEvent>(TEvent @event) where TEvent : Event
{
var handlers = handlerFactory.GetHandlers <TEvent>();
foreach (var handler in handlers)
{
await handler.Handle(@event).ConfigureAwait(false);
}
}
public void Publish <TEvent>(TEvent @event) where TEvent : IEvent
{
IEnumerable <IEventHandler <TEvent> > eventHandlers = _eventHandlerFactory.GetHandlers <TEvent>();
foreach (IEventHandler <TEvent> eventHandler in eventHandlers)
{
eventHandler.Handle(@event);
}
}
public void Publish <T>(T eventInstance) where T : Event
{
var handlers = _eventHandlerFactory.GetHandlers <T>();
foreach (var handler in handlers)
{
handler.Handle(eventInstance);
}
}
public bool Publish <TEvent>(TEvent @event) where TEvent : class, IEventBase
{
var handlers = _eventHandlerFactory.GetHandlers <TEvent>();
if (handlers == null || handlers.Count == 0)
{
return(false);
}
var eventData = @event.ToEventMsg();
Parallel.ForEach(handlers, handler =>
{
var handlerChannelName = GetChannelName <TEvent>(handler.GetType());
_subscriber.Publish(handlerChannelName, eventData);
});
return(true);
}
public void Publish <T>(T @event) where T : DomainEvent
{
// 获得对应的EventHandle来处理事件
var handlers = _eventHandlerFactory.GetHandlers <T>();
foreach (var eventHandler in handlers)
{
// 对事件进行处理
eventHandler.Handle(@event);
}
}
public Task Publish <T>(T @event) where T : Event
{
var t = @event.GetType();
var handlers = _eventHandlers.GetHandlers <T>().ToList();
if (!handlers.Any())
{
throw new InvalidOperationException($"no event handler registered for {typeof(T)}");
}
foreach (var handler in handlers)
{
handler.Handle(@event);
}
return(Task.FromResult(0));
}
