Move remaining legacy workspace event listeners over to new APIs. (#78333)

About 4.1% of main thread CPU costs during solution load are in workspace eventing. This moves nearly all those costs to background threads. The majority of the workspace changed handler costs are associated with ProjectCodeModelFactoy.

If there were any questions about the event handler needing the main thread, this PR attempts to be safe, and continue to use the main thread.

Future PRs can judiciously look at moving event handlers to work on background threads.

Test insertion PR: https://dev.azure.com/devdiv/DevDiv/_git/VS/pullrequest/631924

See PR for before/after images of CPU usage characteristics.

Author: ToddGrun

src/EditorFeatures/Core/EditAndContinue/PdbMatchingSourceTextProvider.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -30,14 +31,22 @@ internal sealed class PdbMatchingSourceTextProvider() : IEventListener, IPdbMatc
     private bool _isActive;
     private int _baselineSolutionVersion;
     private readonly Dictionary<string, (DocumentState state, int solutionVersion)> _documentsWithChangedLoaderByPath = [];
+    private WorkspaceEventRegistration? _workspaceChangedDisposer;
 
     public void StartListening(Workspace workspace)
-        => workspace.WorkspaceChanged += WorkspaceChanged;
+    {
+        Debug.Assert(_workspaceChangedDisposer == null);
+
+        _workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(WorkspaceChanged);
+    }
 
     public void StopListening(Workspace workspace)
-        => workspace.WorkspaceChanged -= WorkspaceChanged;
+    {
+        _workspaceChangedDisposer?.Dispose();
+        _workspaceChangedDisposer = null;
+    }
 
-    private void WorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+    private void WorkspaceChanged(WorkspaceChangeEventArgs e)
     {
         if (!_isActive)
         {

src/EditorFeatures/Core/EditorConfigSettings/Aggregator/SettingsAggregator.cs

@@ -32,7 +32,7 @@ public SettingsAggregator(
         IAsynchronousOperationListener listener)
     {
         _workspace = workspace;
-        _workspace.WorkspaceChanged += UpdateProviders;
+        _ = workspace.RegisterWorkspaceChangedHandler(UpdateProviders);
 
         var currentSolution = _workspace.CurrentSolution.SolutionState;
         UpdateProviders(currentSolution);
@@ -48,7 +48,7 @@ public SettingsAggregator(
             threadingContext.DisposalToken);
     }
 
-    private void UpdateProviders(object? sender, WorkspaceChangeEventArgs e)
+    private void UpdateProviders(WorkspaceChangeEventArgs e)
     {
         switch (e.Kind)
         {

src/EditorFeatures/Core/InlineRename/InlineRenameSession.cs

@@ -51,6 +51,8 @@ internal sealed partial class InlineRenameSession : IInlineRenameSession, IFeatu
     private readonly ITextView _triggerView;
     private readonly IDisposable _inlineRenameSessionDurationLogBlock;
     private readonly IThreadingContext _threadingContext;
+    private readonly WorkspaceEventRegistration _workspaceChangedDisposer;
+
     public readonly InlineRenameService RenameService;
 
     private bool _dismissed;
@@ -161,7 +163,9 @@ public InlineRenameSession(
         _inlineRenameSessionDurationLogBlock = Logger.LogBlock(FunctionId.Rename_InlineSession, CancellationToken.None);
 
         Workspace = workspace;
-        Workspace.WorkspaceChanged += OnWorkspaceChanged;
+
+        // Requires the main thread due to OnWorkspaceChanged calling the Cancel method
+        _workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged, WorkspaceEventOptions.RequiresMainThreadOptions);
 
         _textBufferFactoryService = textBufferFactoryService;
         _textBufferCloneService = textBufferCloneService;
@@ -383,7 +387,7 @@ private void VerifyNotDismissed()
         }
     }
 
-    private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs args)
+    private void OnWorkspaceChanged(WorkspaceChangeEventArgs args)
     {
         if (args.Kind != WorkspaceChangeKind.DocumentChanged)
         {
@@ -701,7 +705,8 @@ private void DismissUIAndRollbackEditsAndEndRenameSession_MustBeCalledOnUIThread
 
         void DismissUIAndRollbackEdits()
         {
-            Workspace.WorkspaceChanged -= OnWorkspaceChanged;
+            _workspaceChangedDisposer.Dispose();
+
             _textBufferAssociatedViewService.SubjectBuffersConnected -= OnSubjectBuffersConnected;
 
             // Reenable completion now that the inline rename session is done

src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.ParseOptionChangedEventSource.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
@@ -13,13 +14,21 @@ internal partial class TaggerEventSources
 {
     private sealed class ParseOptionChangedEventSource(ITextBuffer subjectBuffer) : AbstractWorkspaceTrackingTaggerEventSource(subjectBuffer)
     {
+        private WorkspaceEventRegistration? _workspaceChangedDisposer;
+
         protected override void ConnectToWorkspace(Workspace workspace)
-            => workspace.WorkspaceChanged += OnWorkspaceChanged;
+        {
+            Debug.Assert(_workspaceChangedDisposer == null);
+            _workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged);
+        }
 
         protected override void DisconnectFromWorkspace(Workspace workspace)
-            => workspace.WorkspaceChanged -= OnWorkspaceChanged;
+        {
+            _workspaceChangedDisposer?.Dispose();
+            _workspaceChangedDisposer = null;
+        }
 
-        private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+        private void OnWorkspaceChanged(WorkspaceChangeEventArgs e)
         {
             if (e.Kind == WorkspaceChangeKind.ProjectChanged)
             {

src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.WorkspaceChangedEventSource.cs

@@ -15,6 +15,7 @@ internal partial class TaggerEventSources
     private sealed class WorkspaceChangedEventSource : AbstractWorkspaceTrackingTaggerEventSource
     {
         private readonly AsyncBatchingWorkQueue _asyncDelay;
+        private WorkspaceEventRegistration? _workspaceChangedDisposer;
 
         public WorkspaceChangedEventSource(
             ITextBuffer subjectBuffer,
@@ -36,17 +37,19 @@ public WorkspaceChangedEventSource(
 
         protected override void ConnectToWorkspace(Workspace workspace)
         {
-            workspace.WorkspaceChanged += OnWorkspaceChanged;
+            _workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged);
             this.RaiseChanged();
         }
 
         protected override void DisconnectFromWorkspace(Workspace workspace)
         {
-            workspace.WorkspaceChanged -= OnWorkspaceChanged;
+            _workspaceChangedDisposer?.Dispose();
+            _workspaceChangedDisposer = null;
+
             this.RaiseChanged();
         }
 
-        private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs eventArgs)
+        private void OnWorkspaceChanged(WorkspaceChangeEventArgs eventArgs)
             => _asyncDelay.AddWork();
     }
 }

src/EditorFeatures/Core/SolutionEvents/HostLegacySolutionEventsWorkspaceEventListener.cs

@@ -32,6 +32,8 @@ internal sealed partial class HostLegacySolutionEventsWorkspaceEventListener : I
     private readonly IThreadingContext _threadingContext;
     private readonly AsyncBatchingWorkQueue<WorkspaceChangeEventArgs> _eventQueue;
 
+    private WorkspaceEventRegistration? _workspaceChangedDisposer;
+
     [ImportingConstructor]
     [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
     public HostLegacySolutionEventsWorkspaceEventListener(
@@ -53,16 +55,19 @@ public void StartListening(Workspace workspace)
         // We only support this option to disable crawling in internal speedometer and ddrit perf runs to lower noise.
         // It is not exposed to the user.
         if (_globalOptions.GetOption(SolutionCrawlerRegistrationService.EnableSolutionCrawler))
-            workspace.WorkspaceChanged += OnWorkspaceChanged;
+            _workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged);
     }
 
     public void StopListening(Workspace workspace)
     {
         if (_globalOptions.GetOption(SolutionCrawlerRegistrationService.EnableSolutionCrawler))
-            workspace.WorkspaceChanged -= OnWorkspaceChanged;
+        {
+            _workspaceChangedDisposer?.Dispose();
+            _workspaceChangedDisposer = null;
+        }
     }
 
-    private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+    private void OnWorkspaceChanged(WorkspaceChangeEventArgs e)
     {
         // Legacy workspace events exist solely to let unit testing continue to work using their own fork of solution
         // crawler.  As such, they only need events for the project types they care about.  Specifically, that is only

src/Features/Core/Portable/Diagnostics/CodeAnalysisDiagnosticAnalyzerService.cs

@@ -11,8 +11,6 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.CodeAnalysis.Shared.Utilities;
-using Microsoft.CodeAnalysis.Threading;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Diagnostics;
@@ -52,10 +50,12 @@ public CodeAnalysisDiagnosticAnalyzerService(
             _workspace = workspace;
             _diagnosticAnalyzerService = _workspace.Services.GetRequiredService<IDiagnosticAnalyzerService>();
 
-            _workspace.WorkspaceChanged += OnWorkspaceChanged;
+            // Main thread as OnWorkspaceChanged's call to IDiagnosticAnalyzerService.RequestDiagnosticRefresh isn't clear on
+            // threading requirements
+            _ = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged, WorkspaceEventOptions.RequiresMainThreadOptions);
         }
 
-        private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+        private void OnWorkspaceChanged(WorkspaceChangeEventArgs e)
         {
             switch (e.Kind)
             {

src/Features/Core/Portable/Workspace/CompileTimeSolutionProvider.cs

@@ -65,7 +65,7 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 
     public CompileTimeSolutionProvider(Workspace workspace)
     {
-        workspace.WorkspaceChanged += (s, e) =>
+        _ = workspace.RegisterWorkspaceChangedHandler((e) =>
         {
             if (e.Kind is WorkspaceChangeKind.SolutionCleared or WorkspaceChangeKind.SolutionRemoved)
             {
@@ -79,7 +79,7 @@ public CompileTimeSolutionProvider(Workspace workspace)
                     _lastCompileTimeSolution = null;
                 }
             }
-        };
+        });
     }
 
     private static bool IsRazorAnalyzerConfig(TextDocumentState documentState)

src/VisualStudio/Core/Def/DesignerAttribute/VisualStudioDesignerAttributeService.cs

@@ -60,6 +60,8 @@ internal sealed class VisualStudioDesignerAttributeService :
     // deliver them to VS in batches to prevent flooding the UI thread.
     private readonly AsyncBatchingWorkQueue<DesignerAttributeData> _projectSystemNotificationQueue;
 
+    private WorkspaceEventRegistration? _workspaceChangedDisposer;
+
     [ImportingConstructor]
     [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
     public VisualStudioDesignerAttributeService(
@@ -92,7 +94,7 @@ void IEventListener.StartListening(Workspace workspace)
         if (workspace != _workspace)
             return;
 
-        _workspace.WorkspaceChanged += OnWorkspaceChanged;
+        _workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged);
         _workQueue.AddWork(cancelExistingWork: true);
     }
 
@@ -101,10 +103,11 @@ void IEventListener.StopListening(Workspace workspace)
         if (workspace != _workspace)
             return;
 
-        _workspace.WorkspaceChanged -= OnWorkspaceChanged;
+        _workspaceChangedDisposer?.Dispose();
+        _workspaceChangedDisposer = null;
     }
 
-    private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
+    private void OnWorkspaceChanged(WorkspaceChangeEventArgs e)
     {
         _workQueue.AddWork(cancelExistingWork: true);
     }

src/VisualStudio/Core/Def/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs

@@ -41,6 +41,7 @@ internal abstract partial class AbstractObjectBrowserLibraryManager : AbstractLi
     private ObjectListItem _activeListItem;
     private AbstractListItemFactory _listItemFactory;
     private readonly object _classMemberGate = new();
+    private WorkspaceEventRegistration _workspaceChangedDisposer;
 
     protected AbstractObjectBrowserLibraryManager(
         string languageName,
@@ -53,7 +54,7 @@ protected AbstractObjectBrowserLibraryManager(
         _languageName = languageName;
 
         Workspace = workspace;
-        Workspace.WorkspaceChanged += OnWorkspaceChanged;
+        _workspaceChangedDisposer = Workspace.RegisterWorkspaceChangedHandler(OnWorkspaceChanged);
 
         _libraryService = new Lazy<ILibraryService>(() => Workspace.Services.GetLanguageServices(_languageName).GetService<ILibraryService>());
     }
@@ -73,9 +74,12 @@ private AbstractListItemFactory GetListItemFactory()
     }
 
     public void Dispose()
-        => this.Workspace.WorkspaceChanged -= OnWorkspaceChanged;
+    {
+        _workspaceChangedDisposer?.Dispose();
+        _workspaceChangedDisposer = null;
+    }
 
-    private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
+    private void OnWorkspaceChanged(WorkspaceChangeEventArgs e)
     {
         switch (e.Kind)
         {