- EventBus dispatching parameters to eventhandlers.

- Tests (basic cases, edge cases to follow).

--HG--
branch : dev

src/Orchard.Tests/Events/EventTests.cs

@@ -50,21 +50,37 @@ namespace Orchard.Tests.Events {
             Assert.That(_eventHandler.Count, Is.EqualTo(1));
         }
 
-        public interface ITestEventHandler : IEventHandler {
+        [Test]
-            void Increment();
+        public void EventParametersAreCorrectlyPassedToEventHandlers() {
-        }
+            Assert.That(_eventHandler.Result, Is.EqualTo(0));
-
+            Dictionary<string, object> arguments = new Dictionary<string, object>();
-        public class StubEventHandler : ITestEventHandler {
+            arguments["a"] = 5200;
-            public int Count { get; set; }
+            arguments["b"] = 2600;
-
+            _eventBus.Notify("ITestEventHandler.Substract", arguments);
-            public void Increment() {
+            Assert.That(_eventHandler.Result, Is.EqualTo(2600));
-                Count++;
-            }
         }
 
         [Test]
         public void EventBusThrowsIfMessageNameIsNotCorrectlyFormatted() {
             Assert.Throws<ArgumentException>(() => _eventBus.Notify("StubEventHandlerIncrement", new Dictionary<string, object>()));
         }
+
+        public interface ITestEventHandler : IEventHandler {
+            void Increment();
+            void Substract(int a, int b);
+        }
+
+        public class StubEventHandler : ITestEventHandler {
+            public int Count { get; set; }
+            public int Result { get; set; }
+
+            public void Increment() {
+                Count++;
+            }
+
+            public void Substract(int a, int b) {
+                Result = a - b;
+            }
+        }
     }
 }

src/Orchard/Events/DefaultOrchardEventBus.cs

@@ -37,7 +37,7 @@ namespace Orchard.Events {
             }
         }
 
-        private static void TryInvoke(IEventHandler eventHandler, string interfaceName, string methodName, Dictionary<string, object> arguments) {
+        private static void TryInvoke(IEventHandler eventHandler, string interfaceName, string methodName, IDictionary<string, object> arguments) {
             Type type = eventHandler.GetType();
             foreach (var interfaceType in type.GetInterfaces()) {
                 if (String.Equals(interfaceType.Name, interfaceName, StringComparison.OrdinalIgnoreCase)) {
@@ -47,10 +47,19 @@ namespace Orchard.Events {
             }
         }
 
-        private static void TryInvokeMethod(IEventHandler eventHandler, string methodName, Dictionary<string, object> arguments) {
+        private static void TryInvokeMethod(IEventHandler eventHandler, string methodName, IDictionary<string, object> arguments) {
             foreach (var method in eventHandler.GetType().GetMethods()) {
                 if (String.Equals(method.Name, methodName)) {
-                    method.Invoke(eventHandler, new object[] { });
+                    List<object> parameters = new List<object>();
+                    foreach (var methodParameter in method.GetParameters()) {
+                        if (arguments.ContainsKey(methodParameter.Name)) {
+                            parameters.Add(arguments[methodParameter.Name]);
+                        }
+                        else {
+                            parameters.Add(new object());
+                        }
+                    }
+                    method.Invoke(eventHandler, parameters.ToArray());
                     break;
                 }
             }