Merge pull request #9684 from lifengl/dev/lifengl/preventBlockingThreadPool

Prevent blocking thread pool during initialization.

Author: drewnoakes

src/Microsoft.VisualStudio.ProjectSystem.Managed/GlobalSuppressions.cs

@@ -24,4 +24,3 @@
 [assembly: SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "By design", Scope = "member", Target = "~M:Microsoft.VisualStudio.Threading.TaskResult.EmptyEnumerable``1~System.Threading.Tasks.Task{System.Collections.Generic.IEnumerable{``0}}")]
 [assembly: SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.VisualStudio.ProjectSystem.Debug.LaunchSettingsProviderExtensions.WaitForFirstSnapshot(Microsoft.VisualStudio.ProjectSystem.Debug.ILaunchSettingsProvider,System.Threading.CancellationToken)~System.Threading.Tasks.Task{Microsoft.VisualStudio.ProjectSystem.Debug.ILaunchSettings}")]
 
-[assembly: SuppressMessage("Usage", "VSTHRD102:Implement internal logic asynchronously", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.VisualStudio.ProjectSystem.Debug.LaunchSettingsProvider.WatchLaunchSettingsFile")]

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/LaunchSettingsProvider.cs

@@ -61,9 +61,8 @@ internal class LaunchSettingsProvider : ProjectValueDataSourceBase<ILaunchSettin
     private readonly AsyncLazy<string> _launchSettingsFilePath;
     private readonly SequentialTaskExecutor _sequentialTaskQueue;
     private readonly Lazy<LaunchProfile?> _defaultLaunchProfile;
+    private readonly AsyncLazy<IFileWatcher?> _launchSettingFileWatcher;
 
-    private IFileWatcher? _launchSettingFileWatcher;
-    private int _launchSettingFileWatcherCookie;
     private IReceivableSourceBlock<ILaunchSettings>? _changedSourceBlock;
     private IBroadcastBlock<ILaunchSettings>? _broadcastBlock;
     private IReceivableSourceBlock<IProjectVersionedValue<ILaunchSettings>>? _versionedChangedSourceBlock;
@@ -103,6 +102,10 @@ public LaunchSettingsProvider(
         _sequentialTaskQueue = new SequentialTaskExecutor(new JoinableTaskContextNode(joinableTaskContext), nameof(LaunchSettingsProvider));
 
         _launchSettingsFilePath = new AsyncLazy<string>(GetLaunchSettingsFilePathNoCacheAsync, commonProjectServices.ThreadingService.JoinableTaskFactory);
+        _launchSettingFileWatcher = new AsyncLazy<IFileWatcher?>(WatchLaunchSettingsFileAsync, commonProjectServices.ThreadingService.JoinableTaskFactory)
+        {
+            SuppressRecursiveFactoryDetection = true
+        };
 
         _defaultLaunchProfile = new Lazy<LaunchProfile?>(() =>
         {
@@ -217,8 +220,24 @@ protected override void Initialize()
             JoinUpstreamDataSources(_projectSubscriptionService.ProjectRuleSource, _commonProjectServices.Project.Capabilities);
         }
 
-        // Make sure we are watching the file at this point
-        WatchLaunchSettingsFile();
+        FileChangeScheduler?.Dispose();
+
+        Assumes.Present(_projectServices.ProjectAsynchronousTasks);
+
+        // Create our scheduler for processing file changes
+        FileChangeScheduler = new TaskDelayScheduler(
+            FileChangeProcessingDelay,
+            _commonProjectServices.ThreadingService,
+            _projectServices.ProjectAsynchronousTasks.UnloadCancellationToken);
+
+
+        // establish the file watcher. We don't need wait this, because files can be changed in the system anyway, so blocking our process
+        // doesn't provide real benefit. It is of course possible that the file is changed before the watcher is established. To eliminate this
+        // gap, we can recheck file after the watcher is established. I will skip this for now.
+        _project.Services.FaultHandler.Forget(
+            _launchSettingFileWatcher.GetValueAsync(),
+            _project,
+            severity: ProjectFaultSeverity.LimitedFunctionality);
     }
 
     /// <summary>
@@ -517,16 +536,23 @@ protected async Task HandleLaunchSettingsFileChangedAsync()
         {
             Assumes.NotNull(FileChangeScheduler);
 
-            await FileChangeScheduler.ScheduleAsyncTask(token =>
+            try
             {
-                if (token.IsCancellationRequested)
+                await FileChangeScheduler.ScheduleAsyncTask(token =>
                 {
-                    return Task.CompletedTask;
-                }
+                    if (token.IsCancellationRequested)
+                    {
+                        return Task.CompletedTask;
+                    }
 
-                // Updates need to be sequenced
-                return _sequentialTaskQueue.ExecuteTask(() => UpdateProfilesAsync(null));
-            });
+                    // Updates need to be sequenced
+                    return _sequentialTaskQueue.ExecuteTask(() => UpdateProfilesAsync(null));
+                });
+            }
+            catch (ObjectDisposedException)
+            {
+                // during closing the FileChangeScheduler can be disposed while the task to process the last file change is still running.
+            }
         }
     }
 
@@ -547,53 +573,42 @@ protected async Task EnsureSettingsFolderAsync()
     /// Sets up a file system watcher to look for changes to the launchsettings.json file. It watches at the root of the
     /// project otherwise we force the project to have a properties folder.
     /// </summary>
-    private void WatchLaunchSettingsFile()
+    private async Task<IFileWatcher?> WatchLaunchSettingsFileAsync()
     {
-        if (_launchSettingFileWatcher is null)
-        {
-            FileChangeScheduler?.Dispose();
+        Assumes.Present(_projectServices.ProjectAsynchronousTasks);
+        CancellationToken cancellationToken = _projectServices.ProjectAsynchronousTasks.UnloadCancellationToken;
 
-            Assumes.Present(_projectServices.ProjectAsynchronousTasks);
+        IFileWatcher? fileWatcher = null;
 
-            // Create our scheduler for processing file changes
-            FileChangeScheduler = new TaskDelayScheduler(FileChangeProcessingDelay, _commonProjectServices.ThreadingService,
-                _projectServices.ProjectAsynchronousTasks.UnloadCancellationToken);
+        string launchSettingsToWatch = await GetLaunchSettingsFilePathAsync();
+        if (launchSettingsToWatch is not null)
+        {
+            fileWatcher = await _fileWatcherService.CreateFileWatcherAsync(this, FileWatchChangeKinds.Changed | FileWatchChangeKinds.Added | FileWatchChangeKinds.Removed, cancellationToken);
 
             try
             {
-                JoinableFactory.Run(async () =>
-                {
-                    string launchSettingsToWatch = await GetLaunchSettingsFilePathAsync();
-                    if (launchSettingsToWatch is not null)
-                    {
-                        _launchSettingFileWatcher = await _fileWatcherService.CreateFileWatcherAsync(this, FileWatchChangeKinds.Changed | FileWatchChangeKinds.Added | FileWatchChangeKinds.Removed, CancellationToken.None);
-                        _launchSettingFileWatcherCookie = await _launchSettingFileWatcher.RegisterFileAsync(launchSettingsToWatch, CancellationToken.None);
-                    }
-                });
+                // disposing the file watcher will unregister the file, so we don't have to track the cookie.
+                _ = await fileWatcher.RegisterFileAsync(launchSettingsToWatch, cancellationToken);
             }
             catch (Exception ex) when (ex is IOException || ex is ArgumentException)
             {
                 // If the project folder is no longer available this will throw, which can happen during branch switching
+                await fileWatcher.DisposeAsync();
+                fileWatcher = null;
             }
         }
+
+        return fileWatcher;
     }
 
     protected override void Dispose(bool disposing)
     {
         if (disposing)
         {
-            if (_launchSettingFileWatcher is not null)
-            {
-                if (_launchSettingFileWatcherCookie is not 0)
-                {
-                    // Unregister the file watcher
-                    _launchSettingFileWatcher.Unregister(_launchSettingFileWatcherCookie);
-                    _launchSettingFileWatcherCookie = 0;
-                }
-
-                _launchSettingFileWatcher.Dispose();
-                _launchSettingFileWatcher = null;
-            }
+            _project.Services.FaultHandler.Forget(
+                _launchSettingFileWatcher.DisposeValueAsync(),
+                _project,
+                severity: ProjectFaultSeverity.Recoverable);
 
             if (FileChangeScheduler is not null)
             {