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); }
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); }
/// <summary> /// Build the <see cref="MessageProcessorHost"/> instance. /// </summary> /// <returns>Instance of <see cref="MessageProcessorHost"/>.</returns> public MessageProcessorHost Build() { IMessageHandlerResolver resolver = _registration.BuildMessageHandlerResolver(); IMessageDelegator messageDelegator = new MessageDelegator(resolver); return(new MessageProcessorHost(messageDelegator)); }
// 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 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); }
// 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()); }
/// <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)); }); }
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); }
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); }
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); }
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."); }