Capture handlers on initial raise

src/Features/Core/Diagnostics/DiagnosticService.cs

@@ -58,13 +58,14 @@ internal class DiagnosticService : IDiagnosticService
 
         private void RaiseDiagnosticsUpdated(object sender, DiagnosticsUpdatedArgs args)
         {
-            if (_eventMap.HasEventHandlers<EventHandler<DiagnosticsUpdatedArgs>>(DiagnosticsUpdatedEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<DiagnosticsUpdatedArgs>>(DiagnosticsUpdatedEventName);
+            if (ev.HasHandlers)
             {
                 var eventToken = _listener.BeginAsyncOperation(DiagnosticsUpdatedEventName);
                 _eventQueue.ScheduleTask(() =>
                 {
                     UpdateDataMap(sender, args);
-                    _eventMap.RaiseEvent<EventHandler<DiagnosticsUpdatedArgs>>(DiagnosticsUpdatedEventName, handler => handler(sender, args));
+                    ev.RaiseEvent(handler => handler(sender, args));
                 }).CompletesAsyncOperation(eventToken);
             }
         }

src/Features/Core/SolutionCrawler/SolutionCrawlerProgressReporter.cs

@@ -106,11 +106,12 @@ private Task RaiseStopped()
             private Task RaiseEvent(string eventName)
             {
                 // this method name doesnt have Async since it should work as async void.
-                if (_eventMap.HasEventHandlers<EventHandler>(eventName))
+                var ev = _eventMap.GetEventHandlers<EventHandler>(eventName);
+                if (ev.HasHandlers)
                 {
                     return _eventQueue.ScheduleTask(() =>
                     {
-                        _eventMap.RaiseEvent<EventHandler>(eventName, handler => handler(this, EventArgs.Empty));
+                        ev.RaiseEvent(handler => handler(this, EventArgs.Empty));
                     });
                 }
 

src/Workspaces/Core/Portable/Notification/GlobalOperationNotificationService.cs

@@ -49,11 +49,12 @@ public override GlobalOperationRegistration Start(string operation)
 
         protected virtual Task RaiseGlobalOperationStarted()
         {
-            if (_eventMap.HasEventHandlers<EventHandler>(GlobalOperationStartedEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler>(GlobalOperationStartedEventName);
+            if (ev.HasHandlers)
             {
                 return _eventQueue.ScheduleTask(() =>
                 {
-                    _eventMap.RaiseEvent<EventHandler>(GlobalOperationStartedEventName, handler => handler(this, EventArgs.Empty));
+                    ev.RaiseEvent(handler => handler(this, EventArgs.Empty));
                 });
             }
 
@@ -62,13 +63,14 @@ protected virtual Task RaiseGlobalOperationStarted()
 
         protected virtual Task RaiseGlobalOperationStopped(IReadOnlyList<string> operations, bool cancelled)
         {
-            if (_eventMap.HasEventHandlers<EventHandler<GlobalOperationEventArgs>>(GlobalOperationStoppedEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<GlobalOperationEventArgs>>(GlobalOperationStoppedEventName);
+            if (ev.HasHandlers)
             {
                 var args = new GlobalOperationEventArgs(operations, cancelled);
 
                 return _eventQueue.ScheduleTask(() =>
                 {
-                    _eventMap.RaiseEvent<EventHandler<GlobalOperationEventArgs>>(GlobalOperationStoppedEventName, handler => handler(this, args));
+                    ev.RaiseEvent(handler => handler(this, args));
                 });
             }
 

src/Workspaces/Core/Portable/Utilities/EventMap.cs

@@ -53,23 +53,10 @@ public void RemoveEventHandler<TEventHandler>(string eventName, TEventHandler ev
             }
         }
 
-        public bool HasEventHandlers<TEventHandler>(string eventName)
+        public EventHandlerSet<TEventHandler> GetEventHandlers<TEventHandler>(string eventName)
             where TEventHandler : class
         {
-            return this.GetRegistries<TEventHandler>(eventName).Length > 0;
-        }
-
-        public void RaiseEvent<TEventHandler>(string eventName, Action<TEventHandler> invoker)
-            where TEventHandler : class
-        {
-            var registries = GetRegistries<TEventHandler>(eventName);
-            if (registries.Length > 0)
-            {
-                foreach (var registry in registries)
-                {
-                    registry.Invoke(invoker);
-                }
-            }
+            return new EventHandlerSet<TEventHandler>(this.GetRegistries<TEventHandler>(eventName));
         }
 
         private ImmutableArray<Registry<TEventHandler>> GetRegistries<TEventHandler>(string eventName)
@@ -147,5 +134,32 @@ public override int GetHashCode()
                 return this.handler.GetHashCode();
             }
         }
+
+        internal struct EventHandlerSet<TEventHandler>
+            where TEventHandler : class
+        {
+            private ImmutableArray<Registry<TEventHandler>> registries;
+
+            internal EventHandlerSet(object registries)
+            {
+                this.registries = (ImmutableArray<Registry<TEventHandler>>) registries;
+            }
+
+            public bool HasHandlers
+            {
+                get { return this.registries != null && this.registries.Length > 0; }
+            }
+
+            public void RaiseEvent(Action<TEventHandler> invoker)
+            {
+                if (this.HasHandlers)
+                {
+                    foreach (var registry in registries)
+                    {
+                        registry.Invoke(invoker);
+                    }
+                }
+            }
+        }
     }
 }

src/Workspaces/Core/Portable/Workspace/Workspace_Events.cs

@@ -48,12 +48,13 @@ protected Task RaiseWorkspaceChangedEventAsync(WorkspaceChangeKind kind, Solutio
                 projectId = documentId.ProjectId;
             }
 
-            if (_eventMap.HasEventHandlers<EventHandler<WorkspaceChangeEventArgs>>(WorkspaceChangeEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<WorkspaceChangeEventArgs>>(WorkspaceChangeEventName);
+            if (ev.HasHandlers)
             {
                 return this.ScheduleTask(() =>
                 {
                     var args = new WorkspaceChangeEventArgs(kind, oldSolution, newSolution, projectId, documentId);
-                    _eventMap.RaiseEvent<EventHandler<WorkspaceChangeEventArgs>>(WorkspaceChangeEventName, handler => handler(this, args));
+                    ev.RaiseEvent(handler => handler(this, args));
                 }, "Workspace.WorkspaceChanged");
             }
             else
@@ -81,10 +82,11 @@ protected Task RaiseWorkspaceChangedEventAsync(WorkspaceChangeKind kind, Solutio
 
         protected internal virtual void OnWorkspaceFailed(WorkspaceDiagnostic diagnostic)
         {
-            if (_eventMap.HasEventHandlers<EventHandler<WorkspaceDiagnosticEventArgs>>(WorkspaceFailedEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<WorkspaceDiagnosticEventArgs>>(WorkspaceFailedEventName);
+            if (ev.HasHandlers)
             {
                 var args = new WorkspaceDiagnosticEventArgs(diagnostic);
-                _eventMap.RaiseEvent<EventHandler<WorkspaceDiagnosticEventArgs>>(WorkspaceFailedEventName, handler => handler(this, args));
+                ev.RaiseEvent(handler => handler(this, args));
             }
         }
 
@@ -106,12 +108,13 @@ protected internal virtual void OnWorkspaceFailed(WorkspaceDiagnostic diagnostic
 
         protected Task RaiseDocumentOpenedEventAsync(Document document)
         {
-            if (_eventMap.HasEventHandlers<EventHandler<DocumentEventArgs>>(DocumentOpenedEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<DocumentEventArgs>>(DocumentOpenedEventName);
+            if (ev.HasHandlers)
             {
                 return this.ScheduleTask(() =>
                 {
                     var args = new DocumentEventArgs(document);
-                    _eventMap.RaiseEvent<EventHandler<DocumentEventArgs>>(DocumentOpenedEventName, handler => handler(this, args));
+                    ev.RaiseEvent(handler => handler(this, args));
                 }, "Workspace.WorkspaceChanged");
             }
             else
@@ -138,12 +141,13 @@ protected Task RaiseDocumentOpenedEventAsync(Document document)
 
         protected Task RaiseDocumentClosedEventAsync(Document document)
         {
-            if (_eventMap.HasEventHandlers<EventHandler<DocumentEventArgs>>(DocumentClosedEventName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<DocumentEventArgs>>(DocumentClosedEventName);
+            if (ev.HasHandlers)
             {
                 return this.ScheduleTask(() =>
                 {
                     var args = new DocumentEventArgs(document);
-                    _eventMap.RaiseEvent<EventHandler<DocumentEventArgs>>(DocumentClosedEventName, handler => handler(this, args));
+                    ev.RaiseEvent(handler => handler(this, args));
                 }, "Workspace.DocumentClosed");
             }
             else
@@ -171,12 +175,13 @@ protected Task RaiseDocumentClosedEventAsync(Document document)
 
         protected Task RaiseDocumentActiveContextChangedEventAsync(Document document)
         {
-            if (_eventMap.HasEventHandlers<EventHandler<DocumentEventArgs>>(DocumentActiveContextChangedName))
+            var ev = _eventMap.GetEventHandlers<EventHandler<DocumentEventArgs>>(DocumentActiveContextChangedName);
+            if (ev.HasHandlers)
             {
                 return this.ScheduleTask(() =>
                 {
                     var args = new DocumentEventArgs(document);
-                    _eventMap.RaiseEvent<EventHandler<DocumentEventArgs>>(DocumentActiveContextChangedName, handler => handler(this, args));
+                    ev.RaiseEvent(handler => handler(this, args));
                 }, "Workspace.WorkspaceChanged");
             }
             else