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

@@ -46,6 +46,8 @@ private sealed record CachedServices(
         private readonly SyntacticClassificationTaggerProvider _taggerProvider;
         private readonly ITextBuffer2 _subjectBuffer;
         private readonly WorkspaceRegistration _workspaceRegistration;
+        private WorkspaceEventRegistration? _workspaceChangedDisposer;
+        private WorkspaceEventRegistration? _workspaceDocumentActiveContextChangedDisposer;
 
         private readonly CancellationTokenSource _disposalCancellationSource = new();
 
@@ -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,8 @@ public void DisconnectFromWorkspace()
 
             if (_workspace != null)
             {
-                _workspace.WorkspaceChanged -= this.OnWorkspaceChanged;
-                _workspace.DocumentActiveContextChanged -= this.OnDocumentActiveContextChanged;
+                _workspaceChangedDisposer?.Dispose();
+                _workspaceDocumentActiveContextChangedDisposer?.Dispose();
 
                 _workspace = null;
 
@@ -264,7 +266,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 +279,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

@@ -44,6 +44,8 @@ internal sealed class SolutionChecksumUpdater
 
     private readonly object _gate = new();
     private bool _isSynchronizeWorkspacePaused;
+    private readonly WorkspaceEventRegistration _workspaceChangedDisposer;
+    private readonly WorkspaceEventRegistration _workspaceChangedImmediateDisposer;
 
     private readonly CancellationToken _shutdownToken;
 
@@ -79,8 +81,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 +102,8 @@ public void Shutdown()
         PauseSynchronizingPrimaryWorkspace();
 
         _documentTrackingService.ActiveDocumentChanged -= OnActiveDocumentChanged;
-        _workspace.WorkspaceChanged -= OnWorkspaceChanged;
-        _workspace.WorkspaceChangedImmediate -= OnWorkspaceChangedImmediate;
+        _workspaceChangedDisposer.Dispose();
+        _workspaceChangedImmediateDisposer.Dispose();
 
         if (_globalOperationService != null)
         {
@@ -136,7 +138,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 +149,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/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/Features/Diagnostics/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/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);

src/VisualStudio/Core/Def/ProjectSystem/MiscellaneousFilesWorkspace.cs

@@ -22,6 +22,7 @@
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.TextManager.Interop;
 using Roslyn.Utilities;
+using static Microsoft.CodeAnalysis.WorkspaceEventMap;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 
@@ -172,7 +173,11 @@ private void Registration_WorkspaceChanged(object sender, EventArgs e)
         // to the RDT in the background thread. Since this is all asynchronous a bit more asynchrony is fine.
         if (!_threadingContext.JoinableTaskContext.IsOnMainThread)
         {
-            ScheduleTask(() => Registration_WorkspaceChanged(sender, e));
+            // Require main thread on the callback as this method requires that per the comment above.
+            var handlerAndOptions = new WorkspaceEventHandlerAndOptions(args => Registration_WorkspaceChanged(sender, e), WorkspaceEventOptions.RequiresMainThreadOptions);
+            var handlerSet = EventHandlerSet.Create(handlerAndOptions);
+
+            ScheduleTask(e, handlerSet);
             return;
         }
 

src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/ITextViewWindowVerifierInProcessExtensions.cs

@@ -62,10 +62,9 @@ public static async Task CodeActionAsync(
         CancellationToken cancellationToken = default)
     {
         var events = new List<WorkspaceChangeEventArgs>();
-        void WorkspaceChangedHandler(object sender, WorkspaceChangeEventArgs e) => events.Add(e);
 
         var workspace = await textViewWindowVerifier.TestServices.Shell.GetComponentModelServiceAsync<VisualStudioWorkspace>(cancellationToken);
-        using var workspaceEventRestorer = WithWorkspaceChangedHandler(workspace, WorkspaceChangedHandler);
+        using var _ = workspace.RegisterWorkspaceChangedHandler(e => events.Add(e));
 
         await textViewWindowVerifier.TestServices.Editor.ShowLightBulbAsync(cancellationToken);
 
@@ -155,12 +154,6 @@ await textViewWindowVerifier.TestServices.Workspace.WaitForAllAsyncOperationsAsy
         Assert.NotEqual("text", tokenType);
     }
 
-    private static WorkspaceEventRestorer WithWorkspaceChangedHandler(Workspace workspace, EventHandler<WorkspaceChangeEventArgs> eventHandler)
-    {
-        workspace.WorkspaceChanged += eventHandler;
-        return new WorkspaceEventRestorer(workspace, eventHandler);
-    }
-
     private static LoggerRestorer WithLogger(ILogger logger)
     {
         return new LoggerRestorer(Logger.SetLogger(logger));
@@ -195,23 +188,6 @@ public void LogBlockStart(FunctionId functionId, LogMessage logMessage, int uniq
         }
     }
 
-    private readonly struct WorkspaceEventRestorer : IDisposable
-    {
-        private readonly Workspace _workspace;
-        private readonly EventHandler<WorkspaceChangeEventArgs> _eventHandler;
-
-        public WorkspaceEventRestorer(Workspace workspace, EventHandler<WorkspaceChangeEventArgs> eventHandler)
-        {
-            _workspace = workspace;
-            _eventHandler = eventHandler;
-        }
-
-        public void Dispose()
-        {
-            _workspace.WorkspaceChanged -= _eventHandler;
-        }
-    }
-
     private readonly struct LoggerRestorer : IDisposable
     {
         private readonly ILogger? _logger;