Adding PublishCore so that users can override the behavior of Task.Wh…

…enAll on notification handlers

Fixes #121

src/MediatR/Mediator.cs

@@ -3,6 +3,7 @@
     using Internal;
     using System;
     using System.Collections.Concurrent;
+    using System.Collections.Generic;
     using System.Linq;
     using System.Threading;
     using System.Threading.Tasks;
@@ -70,6 +71,16 @@ public Task Publish<TNotification>(TNotification notification, CancellationToken
                 .Concat(asyncNotificationHandlers)
                 .Concat(cancellableAsyncNotificationHandlers);
 
+            return PublishCore(allHandlers);
+        }
+
+        /// <summary>
+        /// Override in a derived class to control how the tasks are awaited. By default the implementation is <see cref="Task.WhenAll(IEnumerable{Task})" />
+        /// </summary>
+        /// <param name="allHandlers">Enumerable of tasks representing invoking each notification handler</param>
+        /// <returns>A task representing invoking all handlers</returns>
+        protected virtual Task PublishCore(IEnumerable<Task> allHandlers)
+        {
             return Task.WhenAll(allHandlers);
         }
     }

test/MediatR.Tests/AsyncPublishTests.cs

@@ -1,6 +1,7 @@
 namespace MediatR.Tests
 {
     using System;
+    using System.Collections.Generic;
     using System.IO;
     using System.Text;
     using System.Threading.Tasks;
@@ -75,5 +76,51 @@ public async Task Should_resolve_main_handler()
             result.ShouldContain("Ping Pong");
             result.ShouldContain("Ping Pung");
         }
+
+        public class SequentialMediator : Mediator
+        {
+            public SequentialMediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory) 
+                : base(singleInstanceFactory, multiInstanceFactory)
+            {
+            }
+
+            protected override async Task PublishCore(IEnumerable<Task> allHandlers)
+            {
+                foreach (var handler in allHandlers)
+                {
+                    await handler;
+                }
+            }
+        }
+
+        [Fact]
+        public async Task Should_override_with_sequential_firing()
+        {
+            var builder = new StringBuilder();
+            var writer = new StringWriter(builder);
+
+            var container = new Container(cfg =>
+            {
+                cfg.Scan(scanner =>
+                {
+                    scanner.AssemblyContainingType(typeof(AsyncPublishTests));
+                    scanner.IncludeNamespaceContainingType<Ping>();
+                    scanner.WithDefaultConventions();
+                    scanner.AddAllTypesOf(typeof(IAsyncNotificationHandler<>));
+                });
+                cfg.For<TextWriter>().Use(writer);
+                cfg.For<IMediator>().Use<SequentialMediator>();
+                cfg.For<SingleInstanceFactory>().Use<SingleInstanceFactory>(ctx => t => ctx.GetInstance(t));
+                cfg.For<MultiInstanceFactory>().Use<MultiInstanceFactory>(ctx => t => ctx.GetAllInstances(t));
+            });
+
+            var mediator = container.GetInstance<IMediator>();
+
+            await mediator.Publish(new Ping { Message = "Ping" });
+
+            var result = builder.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+            result.ShouldContain("Ping Pong");
+            result.ShouldContain("Ping Pung");
+        }
     }
 }