Merge pull request #88 from ardalis/fix-domainEventDispatcher

Fixing the domain event dispatcher

src/CleanArchitecture.Infrastructure/ContainerSetup.cs

 using Autofac;
 using Autofac.Extensions.DependencyInjection;
-using CleanArchitecture.Core.SharedKernel;
+using CleanArchitecture.Core.Interfaces;
 using CleanArchitecture.Infrastructure.Data;
 using Microsoft.Extensions.DependencyInjection;
 using System;
@@ -21,7 +21,7 @@ namespace CleanArchitecture.Infrastructure
 		{
 			var builder = new ContainerBuilder();
 
-			var coreAssembly = Assembly.GetAssembly(typeof(BaseEntity));
+			var coreAssembly = Assembly.GetAssembly(typeof(IRepository));
 			var infrastructureAssembly = Assembly.GetAssembly(typeof(EfRepository));
 			builder.RegisterAssemblyTypes(coreAssembly, infrastructureAssembly).AsImplementedInterfaces();
 

src/CleanArchitecture.Infrastructure/DomainEvents/DomainEventDispatcher.cs

@@ -21,6 +21,16 @@ namespace CleanArchitecture.Infrastructure.DomainEvents
         }
 
         public async Task Dispatch(BaseDomainEvent domainEvent)
+        {
+            var wrappedHandlers = GetWrappedHandlers(domainEvent);
+
+            foreach (DomainEventHandler handler in wrappedHandlers)
+            {
+                await handler.Handle(domainEvent).ConfigureAwait(false);
+            }
+        }
+
+        public IEnumerable<DomainEventHandler> GetWrappedHandlers(BaseDomainEvent domainEvent)
         {
             Type handlerType = typeof(IHandle<>).MakeGenericType(domainEvent.GetType());
             Type wrapperType = typeof(DomainEventHandler<>).MakeGenericType(domainEvent.GetType());
@@ -28,18 +38,15 @@ namespace CleanArchitecture.Infrastructure.DomainEvents
             IEnumerable<DomainEventHandler> wrappedHandlers = handlers.Cast<object>()
                 .Select(handler => (DomainEventHandler)Activator.CreateInstance(wrapperType, handler));
 
-            foreach (DomainEventHandler handler in wrappedHandlers)
-            {
-                await handler.Handle(domainEvent).ConfigureAwait(false);
-            }
+            return wrappedHandlers;
         }
 
-        private abstract class DomainEventHandler
+        public abstract class DomainEventHandler
         {
             public abstract Task Handle(BaseDomainEvent domainEvent);
         }
 
-        private class DomainEventHandler<T> : DomainEventHandler
+        public class DomainEventHandler<T> : DomainEventHandler
             where T : BaseDomainEvent
         {
             private readonly IHandle<T> _handler;

tests/CleanArchitecture.Tests/Core/DomainEvents/DomainEventDispatcherShould.cs

+using CleanArchitecture.Core.Entities;
+using CleanArchitecture.Core.Events;
+using CleanArchitecture.Infrastructure;
+using CleanArchitecture.Infrastructure.DomainEvents;
+using Xunit;
+
+namespace CleanArchitecture.UnitTests.Core.DomainEvents
+{
+    public class DomainEventDispatcherShould
+    {
+        [Fact]
+        public void NotReturnAnEmptyListOfAvailableHandlers()
+        {
+            var container = ContainerSetup.BaseAutofacInitialization();
+
+            var domainEventDispatcher = new DomainEventDispatcher(container);
+            var toDoItemCompletedEvent = new ToDoItemCompletedEvent(new ToDoItem());
+
+            var handlersForEvent = domainEventDispatcher.GetWrappedHandlers(toDoItemCompletedEvent);
+
+            Assert.NotEmpty(handlersForEvent);
+        }
+    }
+}