Move workspace file removal to BG to avoid UI delay

src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.OpenFileTracker.cs

@@ -7,6 +7,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
@@ -37,6 +38,8 @@ public sealed class OpenFileTracker : IRunningDocumentTableEventListener
 
             private readonly RunningDocumentTableEventTracker _runningDocumentTableEventTracker;
 
+            private readonly AsyncBatchingWorkQueue<string> _closeDocumentQueue;
+
             #region Fields read/written to from multiple threads to track files that need to be checked
 
             /// <summary>
@@ -66,8 +69,7 @@ public sealed class OpenFileTracker : IRunningDocumentTableEventListener
             /// The IVsHierarchies we have subscribed to to watch for any changes to this moniker. We track this per moniker, so
             /// when a document is closed we know what we have to incrementally unsubscribe from rather than having to unsubscribe from everything.
             /// </summary>
-            private readonly MultiDictionary<string, IReferenceCountedDisposable<ICacheEntry<IVsHierarchy, HierarchyEventSink>>> _watchedHierarchiesForDocumentMoniker
-                = new();
+            private readonly MultiDictionary<string, IReferenceCountedDisposable<ICacheEntry<IVsHierarchy, HierarchyEventSink>>> _watchedHierarchiesForDocumentMoniker = new();
 
             #endregion
 
@@ -83,13 +85,24 @@ private readonly MultiDictionary<string, IReferenceCountedDisposable<ICacheEntry
             /// This cutoff of 10 was chosen arbitrarily and with no evidence whatsoever.</remarks>
             private const int CutoffForCheckingAllRunningDocumentTableDocuments = 10;
 
-            private OpenFileTracker(VisualStudioWorkspaceImpl workspace, IVsRunningDocumentTable runningDocumentTable, IComponentModel componentModel)
+            private OpenFileTracker(
+                VisualStudioWorkspaceImpl workspace,
+                IThreadingContext threadingContext,
+                IVsRunningDocumentTable runningDocumentTable,
+                IComponentModel componentModel,
+                IAsynchronousOperationListenerProvider listenerProvider)
             {
                 _workspace = workspace;
                 _foregroundAffinitization = new ForegroundThreadAffinitizedObject(workspace._threadingContext, assertIsForeground: true);
                 _asyncOperationListener = componentModel.GetService<IAsynchronousOperationListenerProvider>().GetListener(FeatureAttribute.Workspace);
                 _runningDocumentTableEventTracker = new RunningDocumentTableEventTracker(workspace._threadingContext,
                     componentModel.GetService<IVsEditorAdaptersFactoryService>(), runningDocumentTable, this);
+
+                _closeDocumentQueue = new AsyncBatchingWorkQueue<string>(
+                    TimeSpan.FromMilliseconds(250),
+                    ProcessCloseDocumentWorkspaceActionsAsync,
+                    listenerProvider.GetListener(FeatureAttribute.Workspace),
+                    threadingContext.DisposalToken);
             }
 
             void IRunningDocumentTableEventListener.OnOpenDocument(string moniker, ITextBuffer textBuffer, IVsHierarchy? hierarchy, IVsWindowFrame? _)
@@ -108,15 +121,19 @@ void IRunningDocumentTableEventListener.OnRenameDocument(string newMoniker, stri
             {
             }
 
-            public static async Task<OpenFileTracker> CreateAsync(VisualStudioWorkspaceImpl workspace, IAsyncServiceProvider asyncServiceProvider)
+            public static async Task<OpenFileTracker> CreateAsync(
+                VisualStudioWorkspaceImpl workspace,
+                IThreadingContext threadingContext,
+                IAsyncServiceProvider asyncServiceProvider,
+                IAsynchronousOperationListenerProvider listenerProvider)
             {
                 var runningDocumentTable = (IVsRunningDocumentTable?)await asyncServiceProvider.GetServiceAsync(typeof(SVsRunningDocumentTable)).ConfigureAwait(true);
                 Assumes.Present(runningDocumentTable);
 
                 var componentModel = (IComponentModel?)await asyncServiceProvider.GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
                 Assumes.Present(componentModel);
 
-                return new OpenFileTracker(workspace, runningDocumentTable, componentModel);
+                return new OpenFileTracker(workspace, threadingContext, runningDocumentTable, componentModel, listenerProvider);
             }
 
             private void TryOpeningDocumentsForMoniker(string moniker, ITextBuffer textBuffer, IVsHierarchy? hierarchy)
@@ -301,30 +318,39 @@ private void TryClosingDocumentsForMoniker(string moniker)
 
                 UnsubscribeFromWatchedHierarchies(moniker);
 
-                _workspace.ApplyChangeToWorkspace(w =>
+                // Don't do expensive workspace work on the UI thread.  Queue this up to be processed in the BG.
+                _closeDocumentQueue.AddWork(moniker);
+            }
+
+            private ValueTask ProcessCloseDocumentWorkspaceActionsAsync(ImmutableArray<string> monikers, CancellationToken _)
+            {
+                return _workspace.ApplyChangeToWorkspaceMaybeAsync(useAsync: true, w =>
                 {
-                    var documentIds = w.CurrentSolution.GetDocumentIdsWithFilePath(moniker);
-                    if (documentIds.IsDefaultOrEmpty)
+                    foreach (var moniker in monikers)
                     {
-                        return;
-                    }
+                        var documentIds = w.CurrentSolution.GetDocumentIdsWithFilePath(moniker);
+                        if (documentIds.IsDefaultOrEmpty)
+                        {
+                            return;
+                        }
 
-                    foreach (var documentId in documentIds)
-                    {
-                        if (w.IsDocumentOpen(documentId) && !_workspace._documentsNotFromFiles.Contains(documentId))
+                        foreach (var documentId in documentIds)
                         {
-                            if (w.CurrentSolution.ContainsDocument(documentId))
+                            if (w.IsDocumentOpen(documentId) && !_workspace._documentsNotFromFiles.Contains(documentId))
                             {
-                                w.OnDocumentClosed(documentId, new FileTextLoader(moniker, defaultEncoding: null));
-                            }
-                            else if (w.CurrentSolution.ContainsAdditionalDocument(documentId))
-                            {
-                                w.OnAdditionalDocumentClosed(documentId, new FileTextLoader(moniker, defaultEncoding: null));
-                            }
-                            else
-                            {
-                                Debug.Assert(w.CurrentSolution.ContainsAnalyzerConfigDocument(documentId));
-                                w.OnAnalyzerConfigDocumentClosed(documentId, new FileTextLoader(moniker, defaultEncoding: null));
+                                if (w.CurrentSolution.ContainsDocument(documentId))
+                                {
+                                    w.OnDocumentClosed(documentId, new FileTextLoader(moniker, defaultEncoding: null));
+                                }
+                                else if (w.CurrentSolution.ContainsAdditionalDocument(documentId))
+                                {
+                                    w.OnAdditionalDocumentClosed(documentId, new FileTextLoader(moniker, defaultEncoding: null));
+                                }
+                                else
+                                {
+                                    Debug.Assert(w.CurrentSolution.ContainsAnalyzerConfigDocument(documentId));
+                                    w.OnAnalyzerConfigDocumentClosed(documentId, new FileTextLoader(moniker, defaultEncoding: null));
+                                }
                             }
                         }
                     }

src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs

@@ -145,7 +145,8 @@ public VisualStudioWorkspaceImpl(ExportProvider exportProvider, IAsyncServicePro
             _textBufferFactoryService.TextBufferCreated += AddTextBufferCloneServiceToBuffer;
             _projectionBufferFactoryService.ProjectionBufferCreated += AddTextBufferCloneServiceToBuffer;
 
-            _ = Task.Run(() => InitializeUIAffinitizedServicesAsync(asyncServiceProvider));
+            var asyncOperationListenerProvider = exportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>()
+            _ = Task.Run(() => InitializeUIAffinitizedServicesAsync(asyncServiceProvider, asyncOperationListenerProvider));
 
             FileChangeWatcher = exportProvider.GetExportedValue<FileChangeWatcherProvider>().Watcher;
             FileWatchedReferenceFactory = exportProvider.GetExportedValue<FileWatchedPortableExecutableReferenceFactory>();
@@ -157,7 +158,7 @@ public VisualStudioWorkspaceImpl(ExportProvider exportProvider, IAsyncServicePro
                     this,
                     exportProvider.GetExportedValue<IDiagnosticAnalyzerService>(),
                     exportProvider.GetExportedValue<IDiagnosticUpdateSourceRegistrationService>(),
-                    exportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>(),
+                    asyncOperationListenerProvider,
                     _threadingContext), isThreadSafe: true);
         }
 
@@ -200,7 +201,9 @@ internal void SubscribeExternalErrorDiagnosticUpdateSourceToSolutionBuildEvents(
             _isExternalErrorDiagnosticUpdateSourceSubscribedToSolutionBuildEvents = true;
         }
 
-        public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asyncServiceProvider)
+        public async Task InitializeUIAffinitizedServicesAsync(
+            IAsyncServiceProvider asyncServiceProvider,
+            IAsynchronousOperationListenerProvider listenerProvider)
         {
             // Create services that are bound to the UI thread
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
@@ -214,7 +217,7 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
             var solutionClosingContext = UIContext.FromUIContextGuid(VSConstants.UICONTEXT.SolutionClosing_guid);
             solutionClosingContext.UIContextChanged += (_, e) => _solutionClosing = e.Activated;
 
-            var openFileTracker = await OpenFileTracker.CreateAsync(this, asyncServiceProvider).ConfigureAwait(true);
+            var openFileTracker = await OpenFileTracker.CreateAsync(this, _threadingContext, asyncServiceProvider, listenerProvider).ConfigureAwait(true);
             var memoryListener = await VirtualMemoryNotificationListener.CreateAsync(this, _threadingContext, asyncServiceProvider, _globalOptions, _threadingContext.DisposalToken).ConfigureAwait(true);
 
             // Update our fields first, so any asynchronous work that needs to use these is able to see the service.