Add the ability to preload parts of the project system

For the csproj and msvbprj project systems, our COM services get called
on the UI thread when project information is being sent our way. This
has the side effect of creating all our "lazily created" MEF services
on that UI thread during that time, which can result in more unnecessary
blocking. Changing how those project systems work would be a hugely
complicated change, but what we can do is take advantage of the
preloading support that exists in VS to ensure we preload what we can
off the UI thread before we hit the legacy code.

Author: jasonmalinowski

src/VisualStudio/CSharp/Impl/CSharpPackage.cs

@@ -54,6 +54,8 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.LanguageService;
 [ProvideLanguageEditorOptionPage(typeof(Options.IntelliSenseOptionPage), "CSharp", null, "IntelliSense", pageNameResourceId: "#103", keywordListResourceId: 312)]
 [ProvideSettingsManifest(PackageRelativeManifestFile = @"UnifiedSettings\csharpSettings.registration.json")]
 [ProvideService(typeof(ICSharpTempPECompilerService), IsAsyncQueryable = false, IsCacheable = true, IsFreeThreaded = true, ServiceName = "C# TempPE Compiler Service")]
+// ICSharpProjectHost requests the language service under the covers, and since that needs the UI thread to create a COM aggregation wrapper, this cannot be free-threaded either
+[ProvideService(typeof(ICSharpProjectHost), IsAsyncQueryable = true, IsCacheable = true, IsFreeThreaded = false, ServiceName = nameof(ICSharpProjectHost))]
 [Guid(Guids.CSharpPackageIdString)]
 internal sealed class CSharpPackage : AbstractPackage<CSharpPackage, CSharpLanguageService>, IVsUserSettingsQuery
 {
@@ -76,6 +78,16 @@ private Task PackageInitializationBackgroundThreadAsync(PackageLoadTasks package
                 var workspace = this.ComponentModel.GetService<VisualStudioWorkspace>();
                 return new TempPECompilerService(workspace.Services.GetService<IMetadataService>());
             }, promote: true);
+
+            // Historically, the ICSharpProjectHost was fetched by calling QueryService for the CSharpLanguage service,
+            // and then casting it to ICSharpProjectHost. We keep that mechanism in place, but we now expose ICSharpProjectHost
+            // as it's own service directly, so that way the request for it is clear and we can do preloading as needed.
+            AddService(typeof(ICSharpProjectHost), (_, cancellationToken, _) =>
+                {
+                    PreloadProjectSystemComponents();
+                    return GetServiceAsync(typeof(CSharpLanguageService), swallowExceptions: false);
+                },
+                promote: true);
         }
         catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.General))
         {

src/VisualStudio/CSharp/Impl/PackageRegistration.pkgdef

@@ -34,6 +34,13 @@
 "Name"="C# Language Service"
 "IsAsyncQueryable"=dword:00000001
 
+[$RootKey$\Services\{1F3B9583-A66A-4be1-A15B-901DA4DB4ACF}]
+@="{13c3bbb4-f18f-4111-9f54-a0fb010d9194}"
+"Name"="ICSharpProjectHost"
+"IsAsyncQueryable"=dword:00000001
+"IsCacheable"=dword:00000001
+"IsFreeThreaded"=dword:00000000
+
 [$RootKey$\Services\{dba64c84-56df-4e20-8aa6-02332a97f474}]
 @="{13c3bbb4-f18f-4111-9f54-a0fb010d9194}"
 "Name"="C# TempPE Compiler Service"

src/VisualStudio/Core/Def/LanguageService/AbstractPackage`2.cs

@@ -28,6 +28,11 @@ internal abstract partial class AbstractPackage<TPackage, TLanguageService> : Ab
     private VisualStudioSymbolSearchService? _symbolSearchService;
     private IVsShell? _shell;
 
+    /// <summary>
+    /// Set to true if we've already preloaded project system components.
+    /// </summary>
+    private bool _projectSystemComponentsPreloaded;
+
     protected AbstractPackage()
     {
     }
@@ -177,4 +182,29 @@ protected virtual void UnregisterObjectBrowserLibraryManager()
         // it is virtual rather than abstract to not break other languages which derived from our
         // base package implementations
     }
+
+    protected void PreloadProjectSystemComponents()
+    {
+        // No reason to do this more than once, but if we do, there's no harm, since we're just fetching services from MEF.
+        if (_projectSystemComponentsPreloaded)
+            return;
+
+        _projectSystemComponentsPreloaded = true;
+
+        // Preload some components so later uses don't block. This is specifically to help out csproj and msvbprj project systems. They push changes
+        // to us on the UI thread as fundamental part of their design. This causes blocking on the UI thread as we create MEF components and JIT code
+        // for the first time, even though those components could have been loaded on the background thread first. This method is called from the two places
+        // we expose a service for the project systems to create us; this can be called by VS's preloading support on a background thread to ensure this is ran
+        // on a background thread so the later calls on the UI thread will block less. For CPS projects, we don't need this, as CPS already creates us on
+        // background threads, so we can just let things load as they're pulled in.
+        //
+        // The expectation is no thread switching should happen here; if we're being called on a background thread that means we're being pulled in
+        // by the preloading logic. If we're being called on the UI thread, that means we might be getting created directly by the project systems
+        // and the UI thread is already blocked, so a switch to the background thread won't unblock the UI thread and might delay us even further.
+        //
+        // As long as there's something that's not cheap to load later, and it'll definitely be used in all csproj/msvbprj scenarios, then it's worth
+        // putting here to preload.
+        var workspace = this.ComponentModel.GetService<VisualStudioWorkspaceImpl>();
+        workspace.PreloadProjectSystemComponents(this.RoslynLanguageName);
+    }
 }

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

@@ -1630,4 +1630,16 @@ private async Task UpdateUIContextAsync(string language, CancellationToken cance
         // value after the main thread switch.
         uiContext.IsActive = this.CurrentSolution.Projects.Any(p => p.Language == language);
     }
+
+    internal void PreloadProjectSystemComponents(string languageName)
+    {
+        // Ensure we have any listeners for WellKnownEventListeners.Workspace warmed up, since these are otherwise created
+        // the first time we make a change to the CurrentSolution
+        base.EnsureEventListeners();
+
+        // Load up the command line parser and warm it up. This generally ensures we have our language specific binaries loaded
+        // and we have the command line parser ready to go, since those tend to be more expensive things to JIT.
+        var commandLineParserService = Services.GetRequiredLanguageService<ICommandLineParserService>(languageName);
+        commandLineParserService.Parse([], null, isInteractive: false, sdkDirectory: null);
+    }
 }

src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicPackage.vb

@@ -74,7 +74,10 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic
                 isMainThreadTask:=False,
                 task:=Function() As Task
                           Try
-                              AddService(GetType(IVbCompilerService), Function(_1, cancellationToken, _2) Task.FromResult(_comAggregate), promote:=True)
+                              AddService(GetType(IVbCompilerService), Function(_1, cancellationToken, _2)
+                                                                          PreloadProjectSystemComponents()
+                                                                          Return Task.FromResult(_comAggregate)
+                                                                      End Function, promote:=True)
 
                               DirectCast(Me, IServiceContainer).AddService(
                                   GetType(IVbTempPECompilerFactory),

src/Workspaces/Core/Portable/Workspace/Workspace_Events.cs

@@ -189,7 +189,7 @@ private EventHandlerSet GetEventHandlers(WorkspaceEventType eventType)
         return _eventMap.GetEventHandlerSet(eventType);
     }
 
-    private void EnsureEventListeners()
+    private protected void EnsureEventListeners()
     {
         // Cache this service so it doesn't need to be retrieved from MEF during disposal.
         _workspaceEventListenerService ??= this.Services.GetService<IWorkspaceEventListenerService>();