- Making IEventHandler an IDependency and related changes to the event bus and the shell container factory.

- Refactoring ZoneManager to use IEventHandlers.
- Other related changes to event handler based components, removing unneeded looping through handlers in the component since the event bus does that.

--HG--
branch : dev

src/Orchard.Core.Tests/Feeds/Controllers/FeedControllerTests.cs

@@ -27,7 +27,8 @@ namespace Orchard.Core.Tests.Feeds.Controllers {
             var controller = new FeedController(
                 Enumerable.Empty<IFeedQueryProvider>(),
                 Enumerable.Empty<IFeedBuilderProvider>(),
-                Enumerable.Empty<IFeedItemBuilder>()) {
+                new StubItemBuilder()
+                ) {
                     ValueProvider = Values.From(new { })
                 };
 
@@ -54,7 +55,8 @@ namespace Orchard.Core.Tests.Feeds.Controllers {
             var controller = new FeedController(
                 new[] { queryProvider.Object },
                 new[] { formatProvider.Object },
-                Enumerable.Empty<IFeedItemBuilder>()) {
+                new StubItemBuilder()
+                ) {
                     ValueProvider = Values.From(new { })
                 };
 
@@ -86,15 +88,20 @@ namespace Orchard.Core.Tests.Feeds.Controllers {
             }
         }
 
+        class StubItemBuilder : IFeedItemBuilder {
+            public void Populate(FeedContext context) {
+            }
+        }
+
         [Test]
         public void RssFeedShouldBeStructuredAppropriately() {
             var query = new StubQuery(Enumerable.Empty<ContentItem>());
 
             var builder = new ContainerBuilder();
-            //builder.RegisterModule(new ImplicitCollectionSupportModule());
             builder.RegisterType<FeedController>();
             builder.RegisterType<RssFeedBuilder>().As<IFeedBuilderProvider>();
             builder.RegisterInstance(query).As<IFeedQueryProvider>();
+            builder.RegisterInstance(new StubItemBuilder()).As<IFeedItemBuilder>();
             var container = builder.Build();
 
             var controller = container.Resolve<FeedController>();
@@ -117,9 +124,9 @@ namespace Orchard.Core.Tests.Feeds.Controllers {
             });
 
             var builder = new ContainerBuilder();
-            //builder.RegisterModule(new ImplicitCollectionSupportModule());
             builder.RegisterType<FeedController>();
             builder.RegisterType<RssFeedBuilder>().As<IFeedBuilderProvider>();
+            builder.RegisterInstance(new StubItemBuilder()).As<IFeedItemBuilder>();
             builder.RegisterInstance(query).As<IFeedQueryProvider>();
             var container = builder.Build();
 

src/Orchard.Web/Core/Feeds/Controllers/FeedController.cs

@@ -10,15 +10,15 @@ namespace Orchard.Core.Feeds.Controllers {
     public class FeedController : Controller {
         private readonly IEnumerable<IFeedBuilderProvider> _feedFormatProviders;
         private readonly IEnumerable<IFeedQueryProvider> _feedQueryProviders;
-        private readonly IEnumerable<IFeedItemBuilder> _feedItemBuilders;
+        private readonly IFeedItemBuilder _feedItemBuilder;
 
         public FeedController(
             IEnumerable<IFeedQueryProvider> feedQueryProviders,
             IEnumerable<IFeedBuilderProvider> feedFormatProviders,
-            IEnumerable<IFeedItemBuilder> feedItemBuilders) {
+            IFeedItemBuilder feedItemBuilder) {
             _feedQueryProviders = feedQueryProviders;
             _feedFormatProviders = feedFormatProviders;
-            _feedItemBuilders = feedItemBuilders;
+            _feedItemBuilder = feedItemBuilder;
             Logger = NullLogger.Instance;
         }
 
@@ -49,9 +49,7 @@ namespace Orchard.Core.Feeds.Controllers {
 
             return context.Builder.Process(context, () => {
                 bestQueryMatch.FeedQuery.Execute(context);
-                foreach (var feedItemBuilder in _feedItemBuilders) {
+                _feedItemBuilder.Populate(context);
-                    feedItemBuilder.Populate(context);
-                }
                 foreach (var contextualizer in context.Response.Contextualizers) {
                     if (ControllerContext != null &&
                         ControllerContext.RequestContext != null) {

src/Orchard.Web/Core/Feeds/StandardBuilders/CorePartsFeedItemBuilder.cs

@@ -9,7 +9,7 @@ using Orchard.Core.Feeds.Models;
 
 namespace Orchard.Core.Feeds.StandardBuilders {
     [UsedImplicitly]
-    public class CorePartsFeedItemBuilder : IFeedItemBuilder, IDependency {
+    public class CorePartsFeedItemBuilder : IFeedItemBuilder {
         private readonly IContentManager _contentManager;
         private readonly RouteCollection _routes;
 

src/Orchard.Web/Core/Scheduling/Services/ScheduledTaskExecutor.cs

@@ -12,7 +12,7 @@ using Orchard.Tasks.Scheduling;
 
 namespace Orchard.Core.Scheduling.Services {
     [UsedImplicitly]
-    public class ScheduledTaskExecutor : IBackgroundTask, IDependency {
+    public class ScheduledTaskExecutor : IBackgroundTask {
         private readonly IClock _clock;
         private readonly IRepository<ScheduledTaskRecord> _repository;
         private readonly IEnumerable<IScheduledTaskHandler> _handlers;

src/Orchard.Web/Modules/Orchard.Comments/Feeds/CommentFeedItemBuilder.cs

@@ -12,7 +12,7 @@ using Orchard.Localization;
 
 namespace Orchard.Comments.Feeds {
     [UsedImplicitly]
-    public class CommentFeedItemBuilder : IFeedItemBuilder, IDependency {
+    public class CommentFeedItemBuilder : IFeedItemBuilder {
         private readonly IContentManager _contentManager;
 
         public CommentFeedItemBuilder(

src/Orchard.Web/Modules/Orchard.Pages/Security/AuthorizationEventHandler.cs

@@ -7,7 +7,7 @@ using Orchard.Security.Permissions;
 
 namespace Orchard.Pages.Security {
     [UsedImplicitly]
-    public class AuthorizationEventHandler : IAuthorizationServiceEventHandler, IDependency {
+    public class AuthorizationEventHandler : IAuthorizationServiceEventHandler {
         public void Checking(CheckAccessContext context) { }
         public void Complete(CheckAccessContext context) { }
         

src/Orchard/Environment/ShellBuilders/ShellContainerFactory.cs

@@ -62,7 +62,9 @@ namespace Orchard.Environment.ShellBuilders {
                             .EnableDynamicProxy(dynamicProxyContext)
                             .InstancePerLifetimeScope();
 
-                        foreach (var interfaceType in item.Type.GetInterfaces().Where(itf => typeof(IDependency).IsAssignableFrom(itf))) {
+                        foreach (var interfaceType in item.Type.GetInterfaces()
+                            .Where(itf => typeof(IDependency).IsAssignableFrom(itf) 
+                                      && !typeof(IEventHandler).IsAssignableFrom(itf))) {
                             registration = registration.As(interfaceType);
                             if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) {
                                 registration = registration.InstancePerMatchingLifetimeScope("shell");

src/Orchard/Events/DefaultOrchardEventBus.cs

@@ -8,9 +8,9 @@ using Orchard.Logging;
 namespace Orchard.Events {
     public class DefaultOrchardEventBus : IEventBus {
         private readonly Func<IEnumerable<IEventBusHandler>> _handlers;
-        private readonly IEnumerable<IEventHandler> _eventHandlers;
+        private readonly Func<IEnumerable<IEventHandler>> _eventHandlers;
 
-        public DefaultOrchardEventBus(Func<IEnumerable<IEventBusHandler>> handlers, IEnumerable<IEventHandler> eventHandlers) {
+        public DefaultOrchardEventBus(Func<IEnumerable<IEventBusHandler>> handlers, Func<IEnumerable<IEventHandler>> eventHandlers) {
             _handlers = handlers;
             _eventHandlers = eventHandlers;
             Logger = NullLogger.Instance;
@@ -34,7 +34,7 @@ namespace Orchard.Events {
             string interfaceName = parameters[0];
             string methodName = parameters[1];
 
-            foreach (var eventHandler in _eventHandlers) {
+            foreach (var eventHandler in _eventHandlers()) {
                 TryInvoke(eventHandler, interfaceName, methodName, eventData);
             }
         }

src/Orchard/Events/IEventHandler.cs

@@ -1,4 +1,4 @@
 namespace Orchard.Events {
-    public interface IEventHandler {
+    public interface IEventHandler : IDependency {
     }
 }

src/Orchard/Tasks/BackgroundService.cs

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using JetBrains.Annotations;
 using Orchard.Logging;
 
@@ -10,9 +9,9 @@ namespace Orchard.Tasks {
 
     [UsedImplicitly]
     public class BackgroundService : IBackgroundService {
-        private readonly IEnumerable<IBackgroundTask> _tasks;
+        private readonly IBackgroundTask _tasks;
 
-        public BackgroundService(IEnumerable<IBackgroundTask> tasks) {
+        public BackgroundService(IBackgroundTask tasks) {
             _tasks = tasks;
             Logger = NullLogger.Instance;
         }
@@ -20,9 +19,7 @@ namespace Orchard.Tasks {
         public ILogger Logger { get; set; }
 
         public void Sweep() {
-            foreach (var task in _tasks) {
+            _tasks.Sweep();
-                task.Sweep();
-            }
         }
     }
 }

src/Orchard/UI/Zones/IZoneManagerEvents.cs

@@ -1,8 +1,9 @@
 using System.Collections.Generic;
 using System.Web.Mvc;
+using Orchard.Events;
 
 namespace Orchard.UI.Zones {
-    public interface IZoneManagerEvents : IEvents {
+    public interface IZoneManagerEvents : IEventHandler {
         void ZoneRendering(ZoneRenderContext context);
         void ZoneItemRendering(ZoneRenderContext context, ZoneItem item);
         void ZoneItemRendered(ZoneRenderContext context, ZoneItem item);

src/Orchard/UI/Zones/ZoneManager.cs

@@ -8,10 +8,10 @@ using Orchard.UI.Navigation;
 namespace Orchard.UI.Zones {
 
     public class ZoneManager : IZoneManager {
-        private readonly IEnumerable<IZoneManagerEvents> _events;
+        private readonly IEnumerable<IZoneManagerEvents> _zoneManagerEventHandler;
 
-        public ZoneManager(IEnumerable<IZoneManagerEvents> events) {
+        public ZoneManager(IEnumerable<IZoneManagerEvents> eventHandler) {
-            _events = events;
+            _zoneManagerEventHandler = eventHandler;
             Logger = NullLogger.Instance;
         }
 
@@ -38,16 +38,23 @@ namespace Orchard.UI.Zones {
                 RenderingItems = groups.SelectMany(x => x.Items).ToList()
             };
 
-            _events.Invoke(x => x.ZoneRendering(context), Logger);
+            foreach (var zoneManagerEventHandler in _zoneManagerEventHandler) {
+                zoneManagerEventHandler.ZoneRendering(context);
+            }
             foreach (var item in context.RenderingItems) {
                 var zoneItem = item;
-                _events.Invoke(x => x.ZoneItemRendering(context, zoneItem), Logger);
+                foreach (var zoneManagerEventHandler in _zoneManagerEventHandler) {
+                    zoneManagerEventHandler.ZoneItemRendering(context, zoneItem);
+                }
                 zoneItem.WasExecuted = true;
                 zoneItem.Execute(html);
-                _events.Invoke(x => x.ZoneItemRendered(context, zoneItem), Logger);
+                foreach (var zoneManagerEventHandler in _zoneManagerEventHandler) {
+                    zoneManagerEventHandler.ZoneItemRendered(context, zoneItem);
+                }
+            }
+            foreach (var zoneManagerEventHandler in _zoneManagerEventHandler) {
+                zoneManagerEventHandler.ZoneRendered(context);
             }
-            _events.Invoke(x => x.ZoneRendered(context), Logger);
-
         }
 
         protected ILogger Logger { get; set; }