Start moving workspace events to fire on background threads

src/Compilers/Test/Core/FX/EventWaiter.cs

@@ -5,11 +5,7 @@
 #nullable disable
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace Roslyn.Test.Utilities
 {
@@ -55,6 +51,25 @@ public EventHandler<T> Wrap<T>(EventHandler<T> input)
             };
         }
 
+        public Action<TEventArgs> Wrap<TEventArgs>(Action<TEventArgs> input)
+        {
+            return args =>
+            {
+                try
+                {
+                    input(args);
+                }
+                catch (Exception ex)
+                {
+                    _capturedException = ex;
+                }
+                finally
+                {
+                    _eventSignal.Set();
+                }
+            };
+        }
+
         /// <summary>
         /// Use this method to block the test until the operation enclosed in the Wrap method completes
         /// </summary>

src/EditorFeatures/Core/Classification/Syntactic/SyntacticClassificationTaggerProvider.TagComputer.cs

@@ -62,6 +62,8 @@ private sealed record CachedServices(
         private readonly TimeSpan _diffTimeout;
 
         private Workspace? _workspace;
+        private WorkspaceEventRegistration? _workspaceChangedDisposer;
+        private WorkspaceEventRegistration? _workspaceDocumentActiveContextChangedDisposer;
 
         /// <summary>
         /// Cached values for the last services we computed for a particular <see cref="Workspace"/> and <see
@@ -224,8 +226,8 @@ private void ConnectToWorkspace(Workspace workspace)
             _taggerProvider.ThreadingContext.ThrowIfNotOnUIThread();
 
             _workspace = workspace;
-            _workspace.WorkspaceChanged += this.OnWorkspaceChanged;
-            _workspace.DocumentActiveContextChanged += this.OnDocumentActiveContextChanged;
+            _workspaceChangedDisposer = _workspace.RegisterWorkspaceChangedHandler(this.OnWorkspaceChanged);
+            _workspaceDocumentActiveContextChangedDisposer = _workspace.RegisterDocumentActiveContextChangedHandler(this.OnDocumentActiveContextChanged);
 
             // Now that we've connected to the workspace, kick off work to reclassify this buffer.
             _workQueue.AddWork(_subjectBuffer.CurrentSnapshot);
@@ -243,8 +245,11 @@ public void DisconnectFromWorkspace()
 
             if (_workspace != null)
             {
-                _workspace.WorkspaceChanged -= this.OnWorkspaceChanged;
-                _workspace.DocumentActiveContextChanged -= this.OnDocumentActiveContextChanged;
+                _workspaceChangedDisposer?.Dispose();
+                _workspaceChangedDisposer = null;
+
+                _workspaceDocumentActiveContextChangedDisposer?.Dispose();
+                _workspaceDocumentActiveContextChangedDisposer = null;
 
                 _workspace = null;
 
@@ -264,7 +269,7 @@ private void OnSubjectBufferChanged(object? sender, TextContentChangedEventArgs
             _workQueue.AddWork(args.After);
         }
 
-        private void OnDocumentActiveContextChanged(object? sender, DocumentActiveContextChangedEventArgs args)
+        private void OnDocumentActiveContextChanged(DocumentActiveContextChangedEventArgs args)
         {
             if (_workspace == null)
                 return;
@@ -277,18 +282,19 @@ private void OnDocumentActiveContextChanged(object? sender, DocumentActiveContex
             _workQueue.AddWork(_subjectBuffer.CurrentSnapshot);
         }
 
-        private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs args)
+        private void OnWorkspaceChanged(WorkspaceChangeEventArgs args)
         {
             // We may be getting an event for a workspace we already disconnected from.  If so,
             // ignore them.  We won't be able to find the Document corresponding to our text buffer,
             // so we can't reasonably classify this anyways.
-            if (args.NewSolution.Workspace != _workspace)
+            var workspace = _workspace;
+            if (args.NewSolution.Workspace != workspace)
                 return;
 
             if (args.Kind != WorkspaceChangeKind.ProjectChanged)
                 return;
 
-            var documentId = _workspace.GetDocumentIdInCurrentContext(_subjectBuffer.AsTextContainer());
+            var documentId = workspace.GetDocumentIdInCurrentContext(_subjectBuffer.AsTextContainer());
             if (args.ProjectId != documentId?.ProjectId)
                 return;
 

src/EditorFeatures/Core/EditAndContinue/ActiveStatementTrackingService.cs

@@ -18,8 +18,8 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
@@ -103,6 +103,8 @@ internal sealed class TrackingSession
         private readonly CancellationTokenSource _cancellationSource = new();
         private readonly IActiveStatementSpanFactory _spanProvider;
         private readonly ICompileTimeSolutionProvider _compileTimeSolutionProvider;
+        private readonly WorkspaceEventRegistration _documentOpenedHandlerDisposer;
+        private readonly WorkspaceEventRegistration _documentClosedHandlerDisposer;
 
         #region lock(_trackingSpans)
 
@@ -121,8 +123,8 @@ public TrackingSession(Workspace workspace, IActiveStatementSpanFactory spanProv
             _spanProvider = spanProvider;
             _compileTimeSolutionProvider = workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>();
 
-            _workspace.DocumentOpened += DocumentOpened;
-            _workspace.DocumentClosed += DocumentClosed;
+            _documentOpenedHandlerDisposer = _workspace.RegisterDocumentOpenedHandler(DocumentOpened);
+            _documentClosedHandlerDisposer = _workspace.RegisterDocumentClosedHandler(DocumentClosed);
         }
 
         internal Dictionary<string, ImmutableArray<ActiveStatementTrackingSpan>> Test_GetTrackingSpans()
@@ -133,16 +135,16 @@ public void EndTracking()
             _cancellationSource.Cancel();
             _cancellationSource.Dispose();
 
-            _workspace.DocumentOpened -= DocumentOpened;
-            _workspace.DocumentClosed -= DocumentClosed;
+            _documentOpenedHandlerDisposer.Dispose();
+            _documentClosedHandlerDisposer.Dispose();
 
             lock (_trackingSpans)
             {
                 _trackingSpans.Clear();
             }
         }
 
-        private void DocumentClosed(object? sender, DocumentEventArgs e)
+        private void DocumentClosed(DocumentEventArgs e)
         {
             if (e.Document.FilePath != null)
             {
@@ -153,7 +155,7 @@ private void DocumentClosed(object? sender, DocumentEventArgs e)
             }
         }
 
-        private void DocumentOpened(object? sender, DocumentEventArgs e)
+        private void DocumentOpened(DocumentEventArgs e)
             => _ = TrackActiveSpansAsync(e.Document);
 
         private async Task TrackActiveSpansAsync(Document designTimeDocument)

src/EditorFeatures/Core/Remote/SolutionChecksumUpdater.cs

@@ -43,7 +43,8 @@ internal sealed class SolutionChecksumUpdater
     private readonly AsyncBatchingWorkQueue _synchronizeActiveDocumentQueue;
 
     private readonly object _gate = new();
-    private bool _isSynchronizeWorkspacePaused;
+    private readonly WorkspaceEventRegistration _workspaceChangedDisposer;
+    private readonly WorkspaceEventRegistration _workspaceChangedImmediateDisposer;
 
     private readonly CancellationToken _shutdownToken;
 
@@ -52,6 +53,8 @@ internal sealed class SolutionChecksumUpdater
     private const string SynchronizeTextChangesStatusSucceededKeyName = nameof(SolutionChecksumUpdater) + "." + SynchronizeTextChangesStatusSucceededMetricName;
     private const string SynchronizeTextChangesStatusFailedKeyName = nameof(SolutionChecksumUpdater) + "." + SynchronizeTextChangesStatusFailedMetricName;
 
+    private bool _isSynchronizeWorkspacePaused;
+
     public SolutionChecksumUpdater(
         Workspace workspace,
         IAsynchronousOperationListenerProvider listenerProvider,
@@ -79,8 +82,8 @@ public SolutionChecksumUpdater(
             shutdownToken);
 
         // start listening workspace change event
-        _workspace.WorkspaceChanged += OnWorkspaceChanged;
-        _workspace.WorkspaceChangedImmediate += OnWorkspaceChangedImmediate;
+        _workspaceChangedDisposer = _workspace.RegisterWorkspaceChangedHandler(this.OnWorkspaceChanged);
+        _workspaceChangedImmediateDisposer = _workspace.RegisterWorkspaceChangedImmediateHandler(OnWorkspaceChangedImmediate);
         _documentTrackingService.ActiveDocumentChanged += OnActiveDocumentChanged;
 
         if (_globalOperationService != null)
@@ -100,8 +103,8 @@ public void Shutdown()
         PauseSynchronizingPrimaryWorkspace();
 
         _documentTrackingService.ActiveDocumentChanged -= OnActiveDocumentChanged;
-        _workspace.WorkspaceChanged -= OnWorkspaceChanged;
-        _workspace.WorkspaceChangedImmediate -= OnWorkspaceChangedImmediate;
+        _workspaceChangedDisposer.Dispose();
+        _workspaceChangedImmediateDisposer.Dispose();
 
         if (_globalOperationService != null)
         {
@@ -136,7 +139,7 @@ private void ResumeSynchronizingPrimaryWorkspace()
         }
     }
 
-    private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+    private void OnWorkspaceChanged(WorkspaceChangeEventArgs _)
     {
         // Check if we're currently paused.  If so ignore this notification.  We don't want to any work in response
         // to whatever the workspace is doing.
@@ -147,7 +150,7 @@ private void OnWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
         }
     }
 
-    private void OnWorkspaceChangedImmediate(object? sender, WorkspaceChangeEventArgs e)
+    private void OnWorkspaceChangedImmediate(WorkspaceChangeEventArgs e)
     {
         if (e.Kind == WorkspaceChangeKind.DocumentChanged)
         {

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

@@ -11,20 +11,21 @@ internal partial class TaggerEventSources
 {
     private sealed class DocumentActiveContextChangedEventSource(ITextBuffer subjectBuffer) : AbstractWorkspaceTrackingTaggerEventSource(subjectBuffer)
     {
+        private WorkspaceEventRegistration? _documentActiveContextChangedDisposer;
+
+        // Require main thread on the callback as RaiseChanged implementors may have main thread dependencies.
         protected override void ConnectToWorkspace(Workspace workspace)
-            => workspace.DocumentActiveContextChanged += OnDocumentActiveContextChanged;
+            => _documentActiveContextChangedDisposer = workspace.RegisterDocumentActiveContextChangedHandler(OnDocumentActiveContextChanged, WorkspaceEventOptions.RequiresMainThreadOptions);
 
         protected override void DisconnectFromWorkspace(Workspace workspace)
-            => workspace.DocumentActiveContextChanged -= OnDocumentActiveContextChanged;
+            => _documentActiveContextChangedDisposer?.Dispose();
 
-        private void OnDocumentActiveContextChanged(object? sender, DocumentActiveContextChangedEventArgs e)
+        private void OnDocumentActiveContextChanged(DocumentActiveContextChangedEventArgs e)
         {
             var document = SubjectBuffer.AsTextContainer().GetOpenDocumentInCurrentContext();
 
             if (document != null && document.Id == e.NewActiveContextDocumentId)
-            {
                 this.RaiseChanged();
-            }
         }
     }
 }

src/Features/Core/Portable/Diagnostics/Service/DiagnosticAnalyzerService_IncrementalAnalyzer.cs

@@ -14,11 +14,8 @@ private DiagnosticIncrementalAnalyzer CreateIncrementalAnalyzer(Workspace worksp
     private DiagnosticIncrementalAnalyzer CreateIncrementalAnalyzerCallback(Workspace workspace)
     {
         // subscribe to active context changed event for new workspace
-        workspace.DocumentActiveContextChanged += OnDocumentActiveContextChanged;
+        _ = workspace.RegisterDocumentActiveContextChangedHandler(args => RequestDiagnosticRefresh());
 
         return new DiagnosticIncrementalAnalyzer(this, AnalyzerInfoCache, this.GlobalOptions);
     }
-
-    private void OnDocumentActiveContextChanged(object? sender, DocumentActiveContextChangedEventArgs e)
-        => RequestDiagnosticRefresh();
 }

src/Features/Lsif/Generator/Program.cs

@@ -182,7 +182,7 @@ private static async Task GenerateWithMSBuildWorkspaceAsync(
         var solutionLoadStopwatch = Stopwatch.StartNew();
 
         using var msbuildWorkspace = MSBuildWorkspace.Create(await Composition.CreateHostServicesAsync());
-        msbuildWorkspace.WorkspaceFailed += (s, e) => logger.Log(e.Diagnostic.Kind == WorkspaceDiagnosticKind.Failure ? LogLevel.Error : LogLevel.Warning, "Problem while loading: " + e.Diagnostic.Message);
+        _ = msbuildWorkspace.RegisterWorkspaceFailedHandler((e) => logger.Log(e.Diagnostic.Kind == WorkspaceDiagnosticKind.Failure ? LogLevel.Error : LogLevel.Warning, "Problem while loading: " + e.Diagnostic.Message));
 
         var solution = await openAsync(msbuildWorkspace, cancellationToken);
 

src/LanguageServer/Protocol/Workspaces/LspWorkspaceRegistrationService.cs

@@ -12,7 +12,11 @@ namespace Microsoft.CodeAnalysis.LanguageServer;
 internal abstract class LspWorkspaceRegistrationService : IDisposable
 {
     private readonly object _gate = new();
+
+    // These arrays are kept in sync, with _workspaceChangedDisposers[i] representing
+    // a disposer for a WorkspaceChanged event on the workspace at _registrations[i]
     private ImmutableArray<Workspace> _registrations = [];
+    private ImmutableArray<WorkspaceEventRegistration> _workspaceChangedDisposers = [];
 
     public ImmutableArray<Workspace> GetAllRegistrations()
     {
@@ -35,28 +39,42 @@ public virtual void Register(Workspace? workspace)
             m["WorkspacePartialSemanticsEnabled"] = workspace.PartialSemanticsEnabled;
         }, workspace));
 
+        // Forward workspace change events for all registered LSP workspaces. Requires main thread as it
+        // fires LspSolutionChanged which hasn't been guaranteed to be thread safe.
+        var workspaceChangedDisposer = workspace.RegisterWorkspaceChangedHandler(OnLspWorkspaceChanged, WorkspaceEventOptions.RequiresMainThreadOptions);
+
         lock (_gate)
         {
             _registrations = _registrations.Add(workspace);
+            _workspaceChangedDisposers = _workspaceChangedDisposers.Add(workspaceChangedDisposer);
         }
-
-        // Forward workspace change events for all registered LSP workspaces.
-        workspace.WorkspaceChanged += OnLspWorkspaceChanged;
     }
 
     public void Deregister(Workspace? workspace)
     {
         if (workspace is null)
             return;
 
-        workspace.WorkspaceChanged -= OnLspWorkspaceChanged;
+        WorkspaceEventRegistration? disposer = null;
         lock (_gate)
         {
-            _registrations = _registrations.Remove(workspace);
+            var index = _registrations.IndexOf(workspace);
+
+            // Handle the case where we were registered with a null workspace, but deregistered
+            // with a non-null workspace
+            if (index >= 0)
+            {
+                _registrations = _registrations.RemoveAt(index);
+
+                disposer = _workspaceChangedDisposers[index];
+                _workspaceChangedDisposers = _workspaceChangedDisposers.RemoveAt(index);
+            }
         }
+
+        disposer?.Dispose();
     }
 
-    private void OnLspWorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
+    private void OnLspWorkspaceChanged(WorkspaceChangeEventArgs e)
     {
         LspSolutionChanged?.Invoke(this, e);
     }
@@ -65,12 +83,13 @@ public void Dispose()
     {
         lock (_gate)
         {
-            foreach (var workspace in _registrations)
+            foreach (var disposer in _workspaceChangedDisposers)
             {
-                workspace.WorkspaceChanged -= OnLspWorkspaceChanged;
+                disposer.Dispose();
             }
 
-            _registrations = _registrations.Clear();
+            _registrations = [];
+            _workspaceChangedDisposers = [];
         }
     }
 
@@ -81,13 +100,3 @@ public void Dispose()
     /// </summary>
     public EventHandler<WorkspaceChangeEventArgs>? LspSolutionChanged;
 }
-
-internal sealed class LspWorkspaceRegisteredEventArgs : EventArgs
-{
-    public Workspace Workspace { get; }
-
-    public LspWorkspaceRegisteredEventArgs(Workspace workspace)
-    {
-        Workspace = workspace;
-    }
-}

src/VisualStudio/Core/Def/LanguageService/AbstractCreateServicesOnTextViewConnection.cs

@@ -26,10 +26,11 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService
 /// Creates services on the first connection of an applicable subject buffer to an IWpfTextView. 
 /// This ensures the services are available by the time an open document or the interactive window needs them.
 /// </summary>
-internal abstract class AbstractCreateServicesOnTextViewConnection : IWpfTextViewConnectionListener
+internal abstract class AbstractCreateServicesOnTextViewConnection : IWpfTextViewConnectionListener, IDisposable
 {
     private readonly string _languageName;
     private readonly AsyncBatchingWorkQueue<ProjectId?> _workQueue;
+    private readonly WorkspaceEventRegistration _workspaceDocumentOpenedDisposer;
     private bool _initialized = false;
 
     protected VisualStudioWorkspace Workspace { get; }
@@ -56,9 +57,12 @@ public AbstractCreateServicesOnTextViewConnection(
                 listenerProvider.GetListener(FeatureAttribute.CompletionSet),
                 threadingContext.DisposalToken);
 
-        Workspace.DocumentOpened += QueueWorkOnDocumentOpened;
+        _workspaceDocumentOpenedDisposer = Workspace.RegisterDocumentOpenedHandler(QueueWorkOnDocumentOpened);
     }
 
+    public void Dispose()
+        => _workspaceDocumentOpenedDisposer.Dispose();
+
     void IWpfTextViewConnectionListener.SubjectBuffersConnected(IWpfTextView textView, ConnectionReason reason, Collection<ITextBuffer> subjectBuffers)
     {
         if (!_initialized)
@@ -96,7 +100,7 @@ private async ValueTask BatchProcessProjectsWithOpenedDocumentAsync(ImmutableSeg
         }
     }
 
-    private void QueueWorkOnDocumentOpened(object sender, DocumentEventArgs e)
+    private void QueueWorkOnDocumentOpened(DocumentEventArgs e)
     {
         if (e.Document.Project.Language == _languageName)
             _workQueue.AddWork(e.Document.Project.Id);