public async Task ShouldRegisterAllEventHandlers()
{
// 6 handlers.
var asyncHandler1 = new TestEventHandler(_outputHelper);
var asyncHandler2 = new TestEventHandler(_outputHelper);
var asyncHandler3 = new TestEventHandler(_outputHelper);
var handler1 = new TestEventHandler(_outputHelper);
var handler2 = new TestEventHandler(_outputHelper);
var handler3 = new TestEventHandler(_outputHelper);
var registration = new MultiMessageHandlerRegistration();
registration.RegisterEventHandler <TestEvent1>(() => asyncHandler1);
registration.RegisterEventHandler <TestEvent1>(() => asyncHandler2);
registration.RegisterEventHandler <TestEvent1>(() => asyncHandler3);
registration.RegisterEventHandler <TestEvent1>(() => handler1.AsEventSyncHandler <TestEvent1>());
registration.RegisterEventHandler <TestEvent1>(() => handler2.AsEventSyncHandler <TestEvent1>());
registration.RegisterEventHandler <TestEvent1>(() => handler3.AsEventSyncHandler <TestEvent1>());
IMessageHandlerResolver resolver = registration.BuildMessageHandlerResolver();
MessageHandlerDelegate eventHandlerDelegate = resolver.ResolveMessageHandler(typeof(TestEvent1));
await eventHandlerDelegate.Invoke(new TestEvent1());
int totalEventsHandledCount = asyncHandler1.HandledEvents.Count +
asyncHandler2.HandledEvents.Count +
asyncHandler3.HandledEvents.Count +
handler1.HandledEvents.Count +
handler2.HandledEvents.Count +
handler3.HandledEvents.Count;
totalEventsHandledCount.Should().Be(6);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Swagger.
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "AspNetCore Basic Registration Sample", Version = "v1"
});
c.IncludeXmlComments(AspNetCoreAppXmlDocPath);
});
// Write-side repository.
services.AddSingleton <IAggregateRootRepository <Product> >((serviceProvider) =>
new PublishingAggregateRootRepository <Product>(new InMemoryAggregateRootRepository <Product>(),
serviceProvider.GetRequiredService <IDomainEventPublisher>())
);
// Domain event publisher.
services.AddSingleton <IDomainEventPublisher, DomainEventPublisher>();
// Read-side repository.
services.AddSingleton <IProductReadSideRepository, InMemoryProductReadSideRepository>();
// Register command delegator.
services.AddSingleton <CommandDelegator>(serviceProvider =>
{
// Register command handlers.
var commandHandlerRegistration = new SingleMessageHandlerRegistration();
commandHandlerRegistration.RegisterCommandHandler(() => new RegisterProductCommandHandler(serviceProvider.GetRequiredService <IAggregateRootRepository <Product> >()));
commandHandlerRegistration.RegisterCommandHandler(() => new ActivateProductCommandHandler(serviceProvider.GetRequiredService <IAggregateRootRepository <Product> >()));
commandHandlerRegistration.RegisterCommandHandler(() => new DeactivateProductCommandHandler(serviceProvider.GetRequiredService <IAggregateRootRepository <Product> >()));
return(new CommandDelegator(commandHandlerRegistration.BuildMessageHandlerResolver()));
});
// Register event delegator.
services.AddSingleton <EventDelegator>((serviceProvider) =>
{
// Register event handlers.
var eventHandlerRegistration = new MultiMessageHandlerRegistration();
eventHandlerRegistration.RegisterEventHandler <ProductRegisteredEvent>(() => new ProductDomainEventsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
eventHandlerRegistration.RegisterEventHandler <ProductActivatedEvent>(() => new ProductDomainEventsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
eventHandlerRegistration.RegisterEventHandler <ProductDeactivatedEvent>(() => new ProductDomainEventsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
return(new EventDelegator(eventHandlerRegistration.BuildMessageHandlerResolver()));
});
// Register query dispatcher.
services.AddSingleton <IQueryAsyncDispatcher>(serviceProvider =>
{
// Register query handlers.
var registration = new QueryHandlerRegistration();
registration.Register(() => new QueryAllProductsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
registration.Register(() => new QueryProductByIdHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
return(new QueryDispatcher(registration));
});
services.AddMvc();
}
public ICqrsEventHandlerSelector ByAttribute(ServiceLifetime lifetime, params Assembly[] assemblies)
{
if (assemblies == null)
{
throw new ArgumentNullException(nameof(assemblies));
}
if (assemblies.Length == 0)
{
throw new ArgumentException("No event handler assemblies were provided.", nameof(assemblies));
}
_serviceCollection.Scan(scan => scan
// Scan distinct assemblies.
.FromAssemblies(assemblies.Distinct())
// Register classes that has a method marked with [EventHandler]
.AddClasses(classes => classes.Where(type => EventHandlerAttributeMethod.IsFoundInType(type)))
.AsSelf()
.WithLifetime(lifetime));
_serviceCollection.AddSingleton <EventHandlerDelegateResolver>(serviceProvider =>
{
var multiMessageHandlerRegistration = new MultiMessageHandlerRegistration();
multiMessageHandlerRegistration.RegisterEventHandlersByAttribute(assemblies, serviceProvider.GetRequiredService);
return(new EventHandlerDelegateResolver(multiMessageHandlerRegistration.BuildMessageHandlerResolver()));
});
return(this);
}
private static MultiMessageHandlerRegistration RegisterEventHandlers(IServiceProvider serviceProvider)
{
// Register event handlers to the message handler registration.
// Events can have multiple handlers so use MultiMessageHandlerRegistration.
var eventHandlerRegistration = new MultiMessageHandlerRegistration();
// ProductRegisteredEvent
eventHandlerRegistration.Register <ProductRegisteredEvent>((message, cancellationToken) =>
{
// You can also manually instantiate if that's how you roll.
var handler = serviceProvider.GetRequiredService <ProductDomainEventsHandler>();
return(handler.HandleProductRegisteredEventAsync(message, cancellationToken));
});
// ProductActivatedEvent
eventHandlerRegistration.Register <ProductActivatedEvent>((message, cancellationToken) =>
{
// You can also manually instantiate if that's how you roll.
var handler = serviceProvider.GetRequiredService <ProductDomainEventsHandler>();
return(handler.HandleProductActivatedEventAsync(message, cancellationToken));
});
// ProductDeactivatedEvent
eventHandlerRegistration.Register <ProductDeactivatedEvent>((message, cancellationToken) =>
{
// You can also manually instantiate if that's how you roll.
var handler = serviceProvider.GetRequiredService <ProductDomainEventsHandler>();
return(handler.HandleProductDeactivatedEventAsync(message, cancellationToken));
});
return(eventHandlerRegistration);
}
public async Task ShouldRegisterAllMethodsMarkedWithEventHandlerAttribute()
{
var attributedHandler1 = new TestAttributedEventHandler(_outputHelper);
var attributedHandler2 = new TestAttributedEventHandler(_outputHelper);
var attributedHandler3 = new TestAttributedEventHandler(_outputHelper);
var registration = new MultiMessageHandlerRegistration();
registration.RegisterEventHandlersByAttribute(() => attributedHandler1);
registration.RegisterEventHandlersByAttribute(EventHandlerAttributeMethod.FromType <TestAttributedEventHandler>(() => attributedHandler2));
registration.RegisterEventHandlersByAttribute(EventHandlerAttributeMethod.FromType(typeof(TestAttributedEventHandler), () => attributedHandler3));
IMessageHandlerResolver resolver = registration.BuildMessageHandlerResolver();
MessageHandlerDelegate eventHandlerDelegate = resolver.ResolveMessageHandler(typeof(TestEvent1));
// Get all methods marked with [EventHandler] and receiving TestEvent as parameter.
int eventHandler1MethodCount = TestAttributedEventHandler.GetEventHandlerAttributeCountFor <TestEvent1>();
int eventHandler2MethodCount = TestAttributedEventHandler.GetEventHandlerAttributeCountFor <TestEvent1>();
int eventHandler3MethodCount = TestAttributedEventHandler.GetEventHandlerAttributeCountFor <TestEvent1>();
await eventHandlerDelegate.Invoke(new TestEvent1());
int totalEventHandlerMethodCount = eventHandler1MethodCount + eventHandler2MethodCount + eventHandler3MethodCount;
int totalEventsHandledCount = attributedHandler1.HandledEvents.Count + attributedHandler2.HandledEvents.Count + attributedHandler3.HandledEvents.Count;
totalEventsHandledCount.Should().Be(totalEventHandlerMethodCount);
}
public static void RegisterEventHandlers(IServiceProvider serviceProvider, MultiMessageHandlerRegistration register)
{
register.RegisterEventHandler <MatchStartedEvent>(() => new MatchEventHandlers(serviceProvider.GetRequiredService <IMatchReadStackRepository>()));
register.RegisterEventHandler <MatchEndedEvent>(() => new MatchEventHandlers(serviceProvider.GetRequiredService <IMatchReadStackRepository>()));
register.RegisterEventHandler <DeployedEvent>(() => new MatchEventHandlers(serviceProvider.GetRequiredService <IMatchReadStackRepository>()));
register.RegisterEventHandler <DestroyedEvent>(() => new MatchEventHandlers(serviceProvider.GetRequiredService <IMatchReadStackRepository>()));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Swagger.
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "AspNetCore Mixed Registration Sample", Version = "v1"
});
c.IncludeXmlComments(AspNetCoreAppXmlDocPath);
});
// Write-side repository.
services.AddSingleton <IProductRepository>((serviceProvider) =>
new PublishingProductRepository(new InMemoryProductRepository(), serviceProvider.GetRequiredService <EventDelegator>())
);
// Read-side repository.
services.AddSingleton <IProductReadSideRepository, InMemoryProductReadSideRepository>();
// Register command delegator.
services.AddSingleton <CommandDelegator>((serviceProvider) =>
{
// Register command handlers through simple registration.
var commandHandlerRegistration = new SingleMessageHandlerRegistration();
commandHandlerRegistration.RegisterCommandHandler(() => new RegisterProductCommandHandler(serviceProvider.GetRequiredService <IProductRepository>()));
commandHandlerRegistration.RegisterCommandHandler(() => new ActivateProductCommandHandler(serviceProvider.GetRequiredService <IProductRepository>()));
commandHandlerRegistration.RegisterCommandHandler(() => new DeactivateProductCommandHandler(serviceProvider.GetRequiredService <IProductRepository>()));
return(new CommandDelegator(commandHandlerRegistration.BuildMessageHandlerResolver()));
});
// Register event delegator.
services.AddSingleton <EventDelegator>((serviceProvider) =>
{
// Register event handlers through simple registration.
var eventHandlerRegistration = new MultiMessageHandlerRegistration();
eventHandlerRegistration.RegisterEventHandler <ProductRegisteredEvent>(() => new ProductDomainEventsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
eventHandlerRegistration.RegisterEventHandler <ProductActivatedEvent>(() => new ProductDomainEventsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
eventHandlerRegistration.RegisterEventHandler <ProductDeactivatedEvent>(() => new ProductDomainEventsHandler(serviceProvider.GetRequiredService <IProductReadSideRepository>()));
return(new EventDelegator(eventHandlerRegistration.BuildMessageHandlerResolver()));
});
// Register query handlers to container.
services.AddTransient <IQueryAsyncHandler <QueryAllProducts, IReadOnlyCollection <ProductReadModel> >, QueryAllProductsHandler>();
services.AddTransient <IQueryAsyncHandler <QueryProductById, ProductReadModel>, QueryProductByIdHandler>();
// Register query dispatcher.
services.AddSingleton <IQueryAsyncDispatcher>(serviceProvider =>
new QueryDispatcher(new ContainerQueryAsyncHandlerResolver(new AspNetCoreServiceProviderAdapter(serviceProvider)))
);
services.AddMvc();
}
public static IMessageHandlerResolver CreateMultiMessageHandlerResolver(Action <MultiMessageHandlerRegistration> registrationAction = null)
{
var registration = new MultiMessageHandlerRegistration();
if (registrationAction != null)
{
registrationAction(registration);
}
return(registration.BuildMessageHandlerResolver());
}
public void ShouldNotAllowNullWhenRegisteringSyncHandler()
{
// Given
Action action = () =>
{
MultiMessageHandlerRegistration registration = CreateMultiHandlerRegistration();
// When
registration.Register((Action <TestMessage>)null);
};
// Then
action.ShouldThrow <ArgumentNullException>("null is not allowed.");
}
public ICqrsEventHandlerSelector ByAttribute(Lifestyle lifeStyle, params Assembly[] assemblies)
{
if (lifeStyle == null)
{
throw new ArgumentNullException(nameof(lifeStyle));
}
if (assemblies == null)
{
throw new ArgumentNullException(nameof(assemblies));
}
if (assemblies.Length == 0)
{
throw new ArgumentException("No event handler assemblies were provided.", nameof(assemblies));
}
// Get all types that has methods marked with [EventHandler] attribute from distinct assemblies.
IEnumerable <Type> foundTypes = assemblies.Distinct()
.SelectMany(assembly => assembly.GetTypes())
.Where(type => type.IsClass &&
!type.IsAbstract &&
EventHandlerAttributeMethod.IsFoundInType(type))
.ToArray();
if (!foundTypes.Any())
{
return(this);
}
foreach (Type type in foundTypes)
{
// Register type as self.
_container.Register(type, type, lifeStyle);
}
var multiMessageHandlerRegistration = new MultiMessageHandlerRegistration();
multiMessageHandlerRegistration.RegisterEventHandlersByAttribute(foundTypes, _container.GetInstance);
// Register resolver.
_container.Collections.AppendTo(
typeof(EventHandlerDelegateResolver),
Lifestyle.Singleton.CreateRegistration(() =>
new EventHandlerDelegateResolver(multiMessageHandlerRegistration.BuildMessageHandlerResolver()),
_container
)
);
return(this);
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services">Service collection.</param>
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
// Swagger.
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "AspNetCore Sample", Version = "v1"
});
c.IncludeXmlComments(AspNetCoreAppXmlDocPath);
});
// Write side repository.
services.AddSingleton <IProductRepository>((serviceProvider) =>
// Use in-memory repository, decorated by a PublishingProductRepository which publishes domain events from the Product aggregate root.
new PublishingProductRepository(new InMemoryProductRepository(), serviceProvider.GetRequiredService <IMessageDelegator>())
);
// Register read side services.
// In this sample, we will just have a read side repository
// which serves as a thin layer between the app layer and the data layer.
services.AddSingleton <IProductReadSideRepository, InMemoryProductReadSideRepository>();
// Register command handlers and event handlers to the container.
services.AddTransient <RegisterProductCommandHandler>();
services.AddTransient <ActivateProductCommandHandler>();
services.AddTransient <DeactivateProductCommandHandler>();
services.AddTransient <ProductDomainEventsHandler>();
// Register message delegator to the container.
services.AddSingleton <IMessageDelegator>((serviceProvider) =>
{
// Register command handlers to the message handler registration.
// Commands can only have one handler so use SingleMessageHandlerRegistration.
SingleMessageHandlerRegistration commandHandlerRegistration = RegisterCommandHandlers(serviceProvider);
// Register event handlers to the message handler registration.
// Events can have multiple handlers so use MultiMessageHandlerRegistration.
MultiMessageHandlerRegistration eventHandlerRegistration = RegisterEventHandlers(serviceProvider);
// Combine command handlers and event handlers.
var resolver = CompositeMessageHandlerResolver.Compose(
commandHandlerRegistration.BuildMessageHandlerResolver(),
eventHandlerRegistration.BuildMessageHandlerResolver()
);
return(new MessageDelegator(resolver));
});
}
public static void RegisterEventHandlers(IServiceProvider serviceProvider, MultiMessageHandlerRegistration register)
{
//rather than lazy's this should probably go through a handler that goes to a singleton saga like the query side does with the repo, but this works too
//game saga
var gameSaga = new Lazy <GameSaga>(() => new GameSaga(serviceProvider.GetRequiredService <CommandDelegator>()));
register.RegisterEventHandler <MatchStartedEvent>(() => gameSaga.Value);
register.RegisterEventHandler <DeployedEvent>(() => gameSaga.Value);
register.RegisterEventHandler <DestroyedEvent>(() => gameSaga.Value);
//match turn saga
var matchTurnSaga = new Lazy <MatchTurnSaga>(() => new MatchTurnSaga(serviceProvider.GetRequiredService <CommandDelegator>()));
register.RegisterEventHandler <AllPlayerMovesSubmittedForTurnEvent>(() => matchTurnSaga.Value);
}
public void ShouldThrowWhenNoHandlerIsResolvedFromMultiMessageHandlerResolve()
{
// Given empty registration
MultiMessageHandlerRegistration registration = CreateMultiHandlerRegistration();
RequiredMessageHandlerResolver requiredResolver = CreateRequiredMessageHandlerResolver(registration.BuildMessageHandlerResolver());
Action action = () =>
{
// When
MessageHandlerDelegate handler = requiredResolver.ResolveMessageHandler(typeof(TestMessage));
};
// Then
action.ShouldThrow <NoMessageHandlerResolvedException>("RequiredMessageHandlerResolver should require a message handler to be found.");
}
public void ShouldAllowMultipleAsyncDelegatesPerMessageType()
{
// Given
Action action = () =>
{
MultiMessageHandlerRegistration registration = CreateMultiHandlerRegistration();
// When
registration.Register <TestMessage>((message, ct) => Task.CompletedTask);
registration.Register <TestMessage>((message, ct) => Task.CompletedTask);
registration.Register <TestMessage>((message, ct) => Task.CompletedTask);
};
// Then
action.ShouldNotThrow <InvalidOperationException>("multiple message handler delegates per message type should be allowed.");
}
private static App Setup(string[] args)
{
// Simple injector.
Container container = new Container();
// Write side repository.
container.RegisterSingleton <IProductRepository>(() =>
// Use in-memory repository, decorated by a PublishingProductRepository which publishes domain events from the Product.
new PublishingProductRepository(new InMemoryProductRepository(), container.GetInstance <IMessageDelegator>())
);
// Register read side services.
// In this sample, we will just have a read side repository
// which serves as a thin layer between the app layer and the data layer.
container.RegisterSingleton <IProductReadSideRepository, InMemoryProductReadSideRepository>();
// Register command handlers and event handlers to the container.
container.Register <RegisterProductCommandHandler>();
container.Register <ActivateProductCommandHandler>();
container.Register <DeactivateProductCommandHandler>();
container.Register <ProductDomainEventsHandler>();
// Register console app use cases.
container.RegisterCollection(typeof(IUseCase), typeof(IUseCase).Assembly);
// Message delegator.
container.RegisterSingleton <IMessageDelegator>(() =>
{
// Register command handlers to the message handler registration.
// Commands can only have one handler so use SingleMessageHandlerRegistration.
SingleMessageHandlerRegistration commandHandlerRegistration = RegisterCommandHandlers(container);
// Register event handlers to the message handler registration.
// Events can have multiple handlers so use MultiMessageHandlerRegistration.
MultiMessageHandlerRegistration eventHandlerRegistration = RegisterEventHandlers(container);
// Combine command handlers and event handlers.
var resolver = CompositeMessageHandlerResolver.Compose(
commandHandlerRegistration.BuildMessageHandlerResolver(),
eventHandlerRegistration.BuildMessageHandlerResolver()
);
return(new MessageDelegator(resolver));
});
return(new App(container));
}
public ICqrsEventHandlerSelector ByAttribute(Lifetime lifetime, params Assembly[] assemblies)
{
if (assemblies == null)
{
throw new System.ArgumentNullException(nameof(assemblies));
}
if (assemblies.Length == 0)
{
throw new ArgumentException("No event handler assemblies were provided.", nameof(assemblies));
}
Assembly[] distinctAssemblies = assemblies.Distinct().ToArray();
var attributeHandlerRegistration = _builder.RegisterAssemblyTypes(distinctAssemblies)
.Where(type => type.IsClass && !type.IsAbstract &&
EventHandlerAttributeMethod.IsFoundInType(type))
.AsSelf();
// Update registration if lifetime is not PerDependency.
switch (lifetime)
{
case Lifetime.PerLifetimeScope:
{
attributeHandlerRegistration.InstancePerLifetimeScope();
}
break;
case Lifetime.Singleton:
{
attributeHandlerRegistration.SingleInstance();
}
break;
}
_builder.Register(context =>
{
var c = context.Resolve <IComponentContext>();
var handlerRegistration = new MultiMessageHandlerRegistration();
handlerRegistration.RegisterEventHandlersByAttribute(distinctAssemblies, c.Resolve);
return(new EventHandlerDelegateResolver(handlerRegistration.BuildMessageHandlerResolver()));
}).AsSelf().SingleInstance();
return(this);
}
public void ShouldAllowMultipleSyncDelegatesPerMessageType()
{
// Given
Action action = () =>
{
MultiMessageHandlerRegistration registration = CreateMultiHandlerRegistration();
// Stub
Action <TestMessage> doNothingAction = (message) => {};
// When
registration.Register <TestMessage>(doNothingAction);
registration.Register <TestMessage>(doNothingAction);
registration.Register <TestMessage>(doNothingAction);
};
// Then
action.ShouldNotThrow <InvalidOperationException>("multiple message handler delegates per message type should be allowed.");
}
private static IServiceProvider BuildContainer()
{
IServiceCollection services = new ServiceCollection();
//setup command stack
CommandStack.Setup.Begin(services);
//setup query stack
ReadStack.Setup.Begin(services);
// Register event delegator.
services.AddSingleton <EventDelegator>((serviceProvider) =>
{
// Register event handlers.
var eventHandlerRegistration = new MultiMessageHandlerRegistration();
CommandStack.Setup.RegisterEventHandlers(serviceProvider, eventHandlerRegistration);
ReadStack.Setup.RegisterEventHandlers(serviceProvider, eventHandlerRegistration);
return(new EventDelegator(eventHandlerRegistration.BuildMessageHandlerResolver()));
});
// Register container adapters to be used by resolvers.
services.AddSingleton <SimpleInjectorContainerAdapter>(new SimpleInjectorContainerAdapter(new Lazy <IServiceProvider>(() => services.BuildServiceProvider())));
return(services.BuildServiceProvider());
}
public void Setup()
{
int numOfIterations = 100000;
var reg = new MultiMessageHandlerRegistration();
var router = new Router();
var mediatrHandlers = new List <INotificationHandler <TestMediatrNotif> >();
for (int i = 0; i < numOfIterations; i++)
{
// Register handlers N number of times each.
reg.Register <TestMessage>(handleMessage);
router.RegisterHandler <TestCqrsliteEvent>(handleCqrsliteMessage);
mediatrHandlers.Add(new TestMediatrNotifHandler());
}
// Delegator.
_delegator = new MessageDelegator(reg.BuildMessageHandlerResolver());
// CQRSLite
_eventPublisher = router;
// Mediatr
_mediator = new Mediator((t) => new object(), (t) => mediatrHandlers);
}
