/// <summary>
/// subscribe domain event in global area
/// </summary>
/// <typeparam name="Event">event</typeparam>
/// <param name="handler"></param>
public void Subscribe <Event>(IDomainEventHandler handler) where Event : class, IDomainEvent
{
if (handler == null)
{
return;
}
var eventType = typeof(Event);
if (!eventHandlerCollection.TryGetValue(eventType.GUID, out Dictionary <EventTriggerTime, List <IDomainEventHandler> > executeTimeHandlers) || executeTimeHandlers == null)
{
executeTimeHandlers = new Dictionary <EventTriggerTime, List <IDomainEventHandler> >()
{
{ handler.ExecuteTime, new List <IDomainEventHandler>()
{
handler
} }
};
}
else
{
if (!executeTimeHandlers.TryGetValue(handler.ExecuteTime, out var handlers) || handlers == null)
{
executeTimeHandlers[handler.ExecuteTime] = new List <IDomainEventHandler>()
{
handler
};
}
else
{
handlers.Add(handler);
}
}
eventHandlerCollection[eventType.GUID] = executeTimeHandlers;
}
public void Setup()
{
unitOfWorkDomainEventHandler1 = Substitute.For<IUnitOfWorkDomainEventHandler<TestDomainEvent, TestUnitOfWork>>();
unitOfWorkDomainEventHandler2 = Substitute.For<IUnitOfWorkDomainEventHandler<TestDomainEvent, TestUnitOfWork>>();
unitOfWorkDomainEventHandlers = new List<IUnitOfWorkDomainEventHandler<TestDomainEvent, TestUnitOfWork>>
{
unitOfWorkDomainEventHandler1,
unitOfWorkDomainEventHandler2
};
domainEventHandler3 = Substitute.For<IDomainEventHandler<TestDomainEvent>>();
domainEventHandler4 = Substitute.For<IDomainEventHandler<TestDomainEvent>>();
domainEventHandlers = new List<IDomainEventHandler<TestDomainEvent>>
{
domainEventHandler3,
domainEventHandler4
};
eventHandlerResolver = Substitute.For<IDomainEventHandlerResolver>();
unitOfWorkEventHandlerResolver = Substitute.For<IUnitOfWorkDomainEventHandlerResolver>();
unitOfWork = Substitute.For<TestUnitOfWork>();
domainEvent = new TestDomainEvent(Guid.NewGuid());
unitOfWorkEventHandlerResolver.ResolveEventHandlers<IUnitOfWorkDomainEventHandler<TestDomainEvent, TestUnitOfWork>>().Returns(unitOfWorkDomainEventHandlers);
eventHandlerResolver.ResolveEventHandlers<IDomainEventHandler<TestDomainEvent>>().Returns(domainEventHandlers);
sut = new TestUnitOfWorkDomainRepository(eventHandlerResolver, unitOfWorkEventHandlerResolver, unitOfWork);
}
public void Setup()
{
unitOfWorkDomainEventHandler1 = Substitute.For <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >();
unitOfWorkDomainEventHandler2 = Substitute.For <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >();
unitOfWorkDomainEventHandlers = new List <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >
{
unitOfWorkDomainEventHandler1,
unitOfWorkDomainEventHandler2
};
domainEventHandler3 = Substitute.For <IDomainEventHandler <TestDomainEvent> >();
domainEventHandler4 = Substitute.For <IDomainEventHandler <TestDomainEvent> >();
domainEventHandlers = new List <IDomainEventHandler <TestDomainEvent> >
{
domainEventHandler3,
domainEventHandler4
};
eventHandlerResolver = Substitute.For <IDomainEventHandlerResolver>();
unitOfWorkEventHandlerResolver = Substitute.For <IUnitOfWorkDomainEventHandlerResolver>();
unitOfWork = Substitute.For <TestUnitOfWork>();
domainEvent = new TestDomainEvent(Guid.NewGuid());
unitOfWorkEventHandlerResolver.ResolveEventHandlers <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >().Returns(unitOfWorkDomainEventHandlers);
eventHandlerResolver.ResolveEventHandlers <IDomainEventHandler <TestDomainEvent> >().Returns(domainEventHandlers);
sut = new TestUnitOfWorkDomainRepository(eventHandlerResolver, unitOfWorkEventHandlerResolver, unitOfWork);
}
public DomainEventAggregator()
{
IDomainEventHandler <PostDomainEvent> postDomainEventHandler =
ServiceLocator.Instance.GetService <IDomainEventHandler <PostDomainEvent> >();
this.Subscribe <PostDomainEvent>(postDomainEventHandler);
}
/// <summary>
/// Determines if the event handler is pre-transaction
/// </summary>
/// <typeparam name="T">The domain event type</typeparam>
/// <param name="handler">The domain event</param>
/// <returns>True, if the event is pre-transaction; otherwise false</returns>
public static bool IsPreTransaction <T>(this IDomainEventHandler <T> handler)
where T : IDomainEvent
{
Validate.IsNotNull(handler);
return(Attribute.IsDefined(handler.GetType(), typeof(PreTransactionHandlerAttribute)));
}
public void CheckEvents()
{
// Note: The AutoOffsetReset property determines the start offset in the event there are not yet any committed offsets for the
// consumer group for the topic/partitions of interest. By default, offsets are committed automatically, so in this example,
// consumption will only start from the earliest message in the topic 'my-topic' the first time you run the program.
consumerConfig.AutoOffsetReset = AutoOffsetReset.Earliest;
using (var c = new ConsumerBuilder <Ignore, string>(consumerConfig).Build())
{
c.Subscribe(kafkaTopic);
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) => {
e.Cancel = true; // prevent the process from terminating.
cts.Cancel();
};
try
{
while (true)
{
try
{
var cr = c.Consume(cts.Token);
//Business logic
if (cr.Value.ToLower().Contains("eventtype"))
{
var orderRequestEventReceived = JsonConvert.DeserializeObject <OrderRequestEvent>(cr.Value);
//if (myEventsAsConsumer.Contains(orderRequestEventReceived.EventType))
if (handlers.ContainsKey(orderRequestEventReceived.EventType))
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("Message Found:");
Console.ResetColor();
Console.WriteLine($"{ orderRequestEventReceived.EventType } - Topic: {cr.Topic} Partition: {cr.Partition} Offset: {cr.Offset} {cr.Value}");
IDomainEventHandler handler = handlers.GetValueOrDefault(orderRequestEventReceived.EventType);
handler.Handler(cr.Value);
}
}
}
catch (ConsumeException e)
{
Console.WriteLine($"Error occured: {e.Error.Reason}");
}
// use the following code just to make demonstration
System.Threading.Thread.Sleep(1000);
}
}
catch (OperationCanceledException)
{
// Ensure the consumer leaves the group cleanly and final offsets are committed.
c.Close();
}
}
}
public EventHandlerWithLogging(
IDomainEventHandler <T> handler,
ILogger <T> log)
{
_handler = handler;
_log = log;
}
/// <summary>
/// Initializes a new instance of the <see cref="DomainEventHandlerResolver" /> class.
/// </summary>
/// <param name="eventHandlerConfiguration">The event handler configuration.</param>
public DomainEventHandlerResolver(Dictionary <String, String[]> eventHandlerConfiguration, Func <Type, IDomainEventHandler> createEventHandlerResolver)
{
this.EventHandlerConfiguration = eventHandlerConfiguration;
this.DomainEventHandlers = new Dictionary <String, IDomainEventHandler>();
List <String> handlers = new List <String>();
// Precreate the Event Handlers here
foreach (KeyValuePair <String, String[]> handlerConfig in eventHandlerConfiguration)
{
handlers.AddRange(handlerConfig.Value);
}
IEnumerable <String> distinctHandlers = handlers.Distinct();
foreach (String handlerTypeString in distinctHandlers)
{
Type handlerType = Type.GetType(handlerTypeString);
if (handlerType == null)
{
throw new NotSupportedException("Event handler configuration is not for a valid type");
}
IDomainEventHandler eventHandler = createEventHandlerResolver(handlerType);
this.DomainEventHandlers.Add(handlerTypeString, eventHandler);
}
}
private void RouteProcessElemToProcessElement <T>(IDomainEventHandler <int> handler, IDomainEvent <int> evt)
where T : DomainEventBase <int>, IProcessElemEvent
{
var castedEvt = evt as T;
(InAggregate.FindEntityById((castedEvt).ProcessElemId) as FirstSubProcess).RaiseEvent(castedEvt);
}
private IDomainEventHandler <IDomainEvent> SetupEventHandler()
{
IDomainEventHandler <IDomainEvent> eventHandler = Substitute.For <IDomainEventHandler <IDomainEvent> >();
eventHandlers.Add(eventHandler);
return(eventHandler);
}
/// <summary>
/// Raise a DomainEvent
/// </summary>
/// <typeparam name="T">The IDomainEvent Type</typeparam>
/// <param name="domainEvent">The domain event</param>
public static void Raise <T>(T domainEvent) where T : IDomainEvent
{
//Raise static Handlers first
foreach (var handler in staticEventHandlers)
{
if (typeof(IDomainEventHandler <T>).IsAssignableFrom(handler))
{
IDomainEventHandler <T> instance = (IDomainEventHandler <T>)_serviceProvider.GetService(handler);
//IDomainEventHandler<T> instance = (IDomainEventHandler<T>)Activator.CreateInstance(handler);
instance.Handle(domainEvent);
}
}
//Raise dynamic handlers
if (dynamicEventHandlers != null)
{
foreach (var handler in dynamicEventHandlers)
{
if (handler is Action <T> )
{
((Action <T>)handler)(domainEvent);
}
}
}
CommitEvent(domainEvent);
}
/// <summary>
/// Initializes a new instance of the <see cref="DomainEventHandlerRegistry"/> class.
/// </summary>
public DomainEventHandlerRegistry()
{
Dictionary <String, String[]> eventHandlersConfiguration = new Dictionary <String, String[]>();
if (Startup.Configuration != null)
{
IConfigurationSection section = Startup.Configuration.GetSection("AppSettings:EventHandlerConfiguration");
if (section != null)
{
Startup.Configuration.GetSection("AppSettings:EventHandlerConfiguration").Bind(eventHandlersConfiguration);
}
}
this.AddSingleton(eventHandlersConfiguration);
this.AddSingleton <Func <Type, IDomainEventHandler> >(container => type =>
{
IDomainEventHandler handler = container.GetService(type) as IDomainEventHandler;
return(handler);
});
this.AddSingleton <EstateDomainEventHandler>();
this.AddSingleton <MerchantDomainEventHandler>();
this.AddSingleton <TransactionDomainEventHandler>();
this.AddSingleton <ContractDomainEventHandler>();
this.AddSingleton <SettlementDomainEventHandler>();
this.AddSingleton <FileProcessorDomainEventHandler>();
this.AddSingleton <MerchantStatementDomainEventHandler>();
this.AddSingleton <IDomainEventHandlerResolver, DomainEventHandlerResolver>();
}
protected void processEvent(IDomainEventHandler <TAggregateId> handler, IDomainEvent <TAggregateId> evt, long version)
{
handler.ProcessEvent(evt);
if (_aggregateProxy.TryCommitEventVersion(version))
{
_aggregateProxy.AddUncommitedEvent(evt);
}
}
public static void RegisterDomainEventHandler(IDomainEventHandler domainEventHandler)
{
if (_domainEventHandlers == null)
{
_domainEventHandlers = new List <IDomainEventHandler>();
}
_domainEventHandlers.Add(domainEventHandler);
}
public void Unregister(IDomainEventHandler <IDomainEvent> handler)
{
var foundHandlers = this.Handlers.Where(x => x.Item2 == handler);
foreach (var foundHandler in foundHandlers)
{
this.Handlers.Remove(foundHandler);
}
}
public DomainEventHandlerAdapter(
IDomainEventHandler <TEvent> handler,
IHubClientFactory hubClientFactory,
IEventSerializer <Event <TEvent> > serializer)
{
_handler = handler;
_hubClientFactory = hubClientFactory;
_serializer = serializer;
}
public void SingleRegisteredEventHandlerIsReturned()
{
IDomainEventHandler <IDomainEvent> eventHandler = SetupEventHandler();
IEnumerable <IDomainEventHandler <TestDomainEvent> > results = sut.ResolveEventHandlers <IDomainEventHandler <TestDomainEvent> >();
Assert.AreEqual(1, results.Count());
Assert.AreSame(eventHandler, results.Single());
}
public void ListenFor <TEvent>(IDomainEventHandler <TEvent> handler, IEventSerializer <Event <TEvent> > serializer)
{
var adapter = new DomainEventHandlerAdapter <TEvent>(
handler,
_hubClientFactory,
serializer);
_adapters.Add(adapter);
}
public DomainEventEntry(Type domainEventType, IDomainEventHandler handler)
{
Contract.Requires(domainEventType != null);
Contract.Requires(handler != null);
DomainEventType = domainEventType;
DomainEventHandler = handler;
DomainEventHandlerType = handler.GetType();
}
public static void RegisterDomainEventHandler(IDomainEventHandler domainEventHandler)
{
if (_domainEventHandlers == null)
{
_domainEventHandlers = new List<IDomainEventHandler>();
}
_domainEventHandlers.Add(domainEventHandler);
}
public static void Deregister <T>(IDomainEventHandler <T> eventHandler)
where T : IDomainEvent
{
lock (handlers)
{
if (handlers.ContainsKey(typeof(T)) && handlers[typeof(T)].Contains(eventHandler))
{
handlers[typeof(T)].Remove(eventHandler);
}
}
}
private static IDomainEventHandler GetCachedHandler(Type handlerType, IDictionary <Type, IDomainEventHandler> handlers)
{
Contract.Requires(handlerType != null);
Contract.Requires(handlers != null);
IDomainEventHandler handler = null;
handlers.TryGetValue(handlerType, out handler);
return(handler);
}
public void MultipleRegisteredEventHandlersAreReturned()
{
IDomainEventHandler <IDomainEvent> eventHandler2 = SetupEventHandler();
IDomainEventHandler <IDomainEvent> eventHandler1 = SetupEventHandler();
IEnumerable <IDomainEventHandler <TestDomainEvent> > results = sut.ResolveEventHandlers <IDomainEventHandler <TestDomainEvent> >();
Assert.AreEqual(2, results.Count());
Assert.IsTrue(results.Contains(eventHandler1));
Assert.IsTrue(results.Contains(eventHandler2));
}
/// <summary>
/// 订阅事件
/// </summary>
public void Subscribe(IDomainEventHandler handler)
{
lock (_handlers)
{
SafeAccessAttribute.CheckUp(handler);
if (!_handlers.Contains(handler))
{
_handlers.Add(handler);
}
}
}
public static void Register <T>(IDomainEventHandler <T> eventHandler)
where T : IDomainEvent
{
lock (handlers)
{
if (!handlers.ContainsKey(typeof(T)))
{
handlers.Add(typeof(T), new List <object>());
}
handlers[typeof(T)].Add(eventHandler);
}
}
/// <summary>
/// 解除领域事件处理器对指定领域事件的订阅。
/// </summary>
/// <typeparam name="TEvent">需要解除订阅的领域事件的类型。</typeparam>
/// <param name="domainEventHandler">需要解除订阅的领域事件处理器。</param>
public static void Unsubscribe <TEvent>(IDomainEventHandler <TEvent> domainEventHandler)
where TEvent : class, IDomainEvent
{
if (domainEventHandlers.ContainsKey(typeof(TEvent)))
{
var handlers = domainEventHandlers[typeof(TEvent)];
if (handlers.Exists(deh => (deh as IDomainEventHandler <TEvent>).Equals(domainEventHandler)))
{
var handlerToRemove = handlers.First(deh => (deh as IDomainEventHandler <TEvent>).Equals(domainEventHandler));
handlers.Remove(handlerToRemove);
}
}
}
/// <summary>
/// 订阅事件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
public static void Subscribe <T>(IDomainEventHandler <T> handler)
where T : IDomainEvent
{
var type = typeof(T);
List <IDomainEventHandler> list = null;
if (!handlerMap.TryGetValue(type, out list))
{
list = new List <IDomainEventHandler>();
handlerMap[type] = list;
}
handlerMap[type].Add((IDomainEventHandler)handler);
}
public void Subscribe(String eventType, IDomainEventHandler handler)
{
if (!_eventRegistry.ContainsKey(eventType))
{
_eventRegistry.Add(eventType, new SortedDictionary <string, IDomainEventHandler>());
}
var handlers = _eventRegistry[eventType];
if (!handlers.ContainsKey(handler.HandlerId))
{
handlers.Add(handler.HandlerId, handler);
}
}
/// <summary>
/// subscribe domain event in global area
/// </summary>
/// <typeparam name="Event">event</typeparam>
/// <param name="handler"></param>
public void SubscribeAll(IDomainEventHandler handler)
{
if (!overallEventHandlerCollection.TryGetValue(handler.ExecuteTime, out var handlers) || handlers == null)
{
handlers = new List <IDomainEventHandler>()
{
handler
};
}
else
{
handlers.Add(handler);
}
overallEventHandlerCollection[handler.ExecuteTime] = handlers;
}
public void RegisterHandler <TEvent>(IDomainEventHandler handler)
where TEvent : IDomainEvent
{
if (_handlers.ContainsKey(typeof(TEvent)) &&
_handlers[typeof(TEvent)].Any(h => h.GetType() == handler.GetType()))
{
throw new ArgumentException($"Handler of type {handler.GetType()} already registered.", nameof(handler));
}
_handlers.AddOrUpdate(typeof(TEvent),
new List <IDomainEventHandler> {
handler
},
(type, list) => { list.Add(handler); return(list); });
}
void IEventDriven <TAggregateId> .ProcessEvent(IDomainEvent <TAggregateId> evt, long version)
{
IDomainEventHandler <TAggregateId> handler = null;
bool existHandler()
{
handler = EventHandlerMap.GetHandlers(evt.GetType());
return(handler != null);
}
if (!_aggregateProxy.ExistUncommitedEvent(x => Equals(x.EventId, evt.EventId)) && existHandler())
{
handler.Continue(evt);
}
}
public async Task <IActionResult> PostEventGolfClubMembership([FromBody] DomainEvent @event,
CancellationToken cancellationToken)
{
try
{
IDomainEventHandler domainEventHandler = this.DomainEventHandlerResolver("GolfClubMembership");
await domainEventHandler.Handle(@event, cancellationToken);
}
catch (WrongExpectedVersionException)
{
return(this.BadRequest());
}
//TODO: Handle NAK scenarios
return(this.Ok());
}
public void Setup()
{
domainEventHandler1 = Substitute.For<IDomainEventHandler<TestDomainEvent>>();
domainEventHandler2 = Substitute.For<IDomainEventHandler<TestDomainEvent>>();
IEnumerable<IDomainEventHandler<TestDomainEvent>> eventHandlers = new List<IDomainEventHandler<TestDomainEvent>>
{
domainEventHandler1,
domainEventHandler2
};
domainEvent = new TestDomainEvent(Guid.NewGuid());
eventHandlerResolver = Substitute.For<IDomainEventHandlerResolver>();
eventHandlerResolver.ResolveEventHandlers<IDomainEventHandler<TestDomainEvent>>().Returns(eventHandlers);
sut = new TestDomainRepository(eventHandlerResolver);
}
public void Setup()
{
domainEventHandler1 = Substitute.For<IDomainEventHandler<TestDomainEvent>>();
domainEventHandler2 = Substitute.For<IDomainEventHandler<TestDomainEvent>>();
domainEventHandler3 = Substitute.For<IDomainEventHandler<AnotherTestDomainEvent>>();
asyncDomainEventHandler1 = Substitute.For<IAsyncDomainEventHandler<TestDomainEvent>>();
asyncDomainEventHandler2 = Substitute.For<IAsyncDomainEventHandler<TestDomainEvent>>();
asyncDomainEventHandler3 = Substitute.For<IAsyncDomainEventHandler<AnotherTestDomainEvent>>();
resolver = Substitute.For<IDomainEventHandlerResolver>();
resolver.ResolveEventHandlers<IDomainEventHandler<TestDomainEvent>>().Returns(new[] { domainEventHandler1, domainEventHandler2 });
resolver.ResolveEventHandlers<IDomainEventHandler<TestDomainEvent>>().Returns(new[] { domainEventHandler1, domainEventHandler2 });
resolver.ResolveEventHandlers<IDomainEventHandler<AnotherTestDomainEvent>>().Returns(new[] { domainEventHandler3 });
resolver.ResolveEventHandlers<IAsyncDomainEventHandler<TestDomainEvent>>().Returns(new[] { asyncDomainEventHandler1, asyncDomainEventHandler2 });
resolver.ResolveEventHandlers<IAsyncDomainEventHandler<TestDomainEvent>>().Returns(new[] { asyncDomainEventHandler1, asyncDomainEventHandler2 });
resolver.ResolveEventHandlers<IAsyncDomainEventHandler<AnotherTestDomainEvent>>().Returns(new[] { asyncDomainEventHandler3 });
sut = new DomainEventBroker(resolver);
}
/// <summary>
/// 初始化一个<c>OrderServiceImpl</c>类型的实例。
/// </summary>
/// <param name="context">用来初始化<c>OrderServiceImpl</c>类型的仓储上下文实例。</param>
/// <param name="shoppingCartRepository">“购物篮”仓储实例。</param>
/// <param name="shoppingCartItemRepository">“购物篮项目”仓储实例。</param>
/// <param name="productRepository">“笔记本电脑”仓储实例。</param>
/// <param name="customerRepository">“客户”仓储实例。</param>
/// <param name="salesOrderRepository">“销售订单”仓储实例。</param>
public OrderServiceImpl(IRepositoryContext context,
IShoppingCartRepository shoppingCartRepository,
IShoppingCartItemRepository shoppingCartItemRepository,
IProductRepository productRepository,
IUserRepository customerRepository,
ISalesOrderRepository salesOrderRepository,
IDomainService domainService,
IDomainEventHandler<OrderDispatchedEvent>[] orderDispatchedDomainEventHandlers)
:base(context)
{
this.shoppingCartRepository = shoppingCartRepository;
this.shoppingCartItemRepository = shoppingCartItemRepository;
this.productRepository = productRepository;
this.userRepository = customerRepository;
this.salesOrderRepository = salesOrderRepository;
this.domainService = domainService;
this.orderDispatchedDomainEventHandlers.AddRange(orderDispatchedDomainEventHandlers);
foreach (var handler in this.orderDispatchedDomainEventHandlers)
DomainEventAggregator.Subscribe<OrderDispatchedEvent>(handler);
DomainEventAggregator.Subscribe<OrderConfirmedEvent>(orderConfirmedEventHandlerAction);
DomainEventAggregator.Subscribe<OrderConfirmedEvent>(orderConfirmedEventHandlerAction2);
}
protected void RegisterHandler(IDomainEventHandler handler)
{
Contract.Requires<ArgumentNullException>(handler != null, "The handler cannot be null.");
_eventHandlers.Add(handler);
}
void IAggregateRoot.AddEvent(IDomainEventHandler eventHandler)
{
AddEvent(eventHandler as DomainEventHandler);
}
