Edition 0 Updated to asp. Net core 0

The domain event dispatcher: mapping from events to event handlers 
Once you’re able to dispatch or publish 
the events, you need some kind of artifact that will publish the 
event, so that every related handler can get it and process side effects based on that event. 
One approach is a real messaging system or even an event bus, possibly based on a service bus as 
opposed to in-memory events. However, for the first case, real messaging would be overkill for 
processing domain events, since you just need to process those events within the same process (that 
is, within the same domain and application layer). 
Another way to map events to multiple event handlers is by using types registration in an IoC 
container so you can dynamically infer where to dispatch the events. In other words, you need to 
know what event handlers need to get a specific event. Figure 7-16 shows a simplified approach for 
this approach. 
Figure 7-16. Domain event dispatcher using IoC 
You can build all the plumbing and artifacts to implement that approach by yourself. However, you 
can also use available libraries like 
MediatR
 that uses your IoC container under the covers. You can 
therefore directly use the predefined interfaces and the mediator object’s publish/dispatch methods.

---

237 
CHAPTER 6 | Tackle Business Complexity in a Microservice with DDD and CQRS Patterns 
In code, you first need to register the event handler types in your IoC container, as shown in the 
following example at 
eShopOnContainers Ordering microservice
: 
public
class
MediatorModule : Autofac.
Module
{ 
protected
override
void
Load
(ContainerBuilder builder) 
{ 
// Other registrations ...
// Register the DomainEventHandler classes (they implement 
IAsyncNotificationHandler<>)
// in assembly holding the Domain Events
builder.
RegisterAssemblyTypes
(
typeof
(ValidateOrAddBuyerAggregateWhenOrderStartedDomainEvent
Handler) 
.
GetTypeInfo
().
Assembly
) 
.
AsClosedTypesOf
(
typeof
(IAsyncNotificationHandler<>)); 
// Other registrations ...
} 
} 
The code first identifies the assembly that contains the domain event handlers by locating the 
assembly that holds any of the handlers (using typeof(ValidateOrAddBuyerAggregateWhenXxxx), but 
you could have chosen any other event handler to locate the assembly). Since all the event handlers 
implement the IAsyncNotificationHandler interface, the code then just searches for those types and 
registers all the event handlers.