diff --git a/eng/config/BannedSymbols.txt b/eng/config/BannedSymbols.txt
index 631138488c6ed..561099efd2ece 100644
--- a/eng/config/BannedSymbols.txt
+++ b/eng/config/BannedSymbols.txt
@@ -26,8 +26,6 @@ M:Microsoft.CodeAnalysis.Document.GetOptionsAsync(System.Threading.CancellationT
 T:Microsoft.CodeAnalysis.Options.DocumentOptionSet; Use AnalyzerConfigOptions instead
 M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetService``2(System.IServiceProvider); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing.
 M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetService``2(System.IServiceProvider,System.Boolean); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
-M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetServiceAsync``2(Microsoft.VisualStudio.Shell.IAsyncServiceProvider); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
-M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetServiceAsync``2(Microsoft.VisualStudio.Shell.IAsyncServiceProvider,System.Boolean); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
 P:Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory; Use IThreadingContext.JoinableTaskFactory instead.
 M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use internal overload instead
 M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
diff --git a/src/EditorFeatures/Core.Wpf/Utilities/RoslynServiceExtensions.cs b/src/EditorFeatures/Core.Wpf/Utilities/RoslynServiceExtensions.cs
index ca260ca0abe8d..5e19cbd3656a6 100644
--- a/src/EditorFeatures/Core.Wpf/Utilities/RoslynServiceExtensions.cs
+++ b/src/EditorFeatures/Core.Wpf/Utilities/RoslynServiceExtensions.cs
@@ -4,8 +4,6 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Threading;
 
 namespace Microsoft.VisualStudio.Shell
@@ -25,12 +23,6 @@ public static TInterface GetServiceOnMainThread<TService, TInterface>(this IServ
             return @interface;
         }
 
-        /// <summary>
-        /// Returns the specified service type from the service.
-        /// </summary>
-        public static TServiceType GetServiceOnMainThread<TServiceType>(this IServiceProvider serviceProvider) where TServiceType : class
-            => serviceProvider.GetServiceOnMainThread<TServiceType, TServiceType>();
-
         /// <summary>
         /// Gets a service interface from a service provider.
         /// </summary>
@@ -99,88 +91,5 @@ public static TInterface GetService<TService, TInterface>(
                 return @interface;
             });
         }
-
-        /// <summary>
-        /// Gets a service interface from a service provider asynchronously.
-        /// </summary>
-        /// <typeparam name="TService">The service type</typeparam>
-        /// <typeparam name="TInterface">The interface type</typeparam>
-        /// <param name="asyncServiceProvider">The async service provider</param>
-        /// <returns>The requested service interface. Never <see langword="null"/>.</returns>
-        /// <exception cref="ServiceUnavailableException">
-        /// Either the service could not be acquired, or the service does not support
-        /// the requested interface.
-        /// </exception>
-        public static Task<TInterface> GetServiceAsync<TService, TInterface>(
-            this IAsyncServiceProvider asyncServiceProvider,
-            JoinableTaskFactory joinableTaskFactory)
-            where TInterface : class
-        {
-            return GetServiceAsync<TService, TInterface>(asyncServiceProvider, joinableTaskFactory, throwOnFailure: true)!;
-        }
-
-        /// <summary>
-        /// Gets a service interface from a service provider asynchronously.
-        /// </summary>
-        /// <typeparam name="TService">The service type</typeparam>
-        /// <typeparam name="TInterface">The interface type</typeparam>
-        /// <param name="asyncServiceProvider">The async service provider</param>
-        /// <param name="throwOnFailure">
-        /// Determines how a failure to get the requested service interface is handled. If <see langword="true"/>, an
-        /// exception is thrown; if <see langword="false"/>, <see langword="null"/> is returned.
-        /// </param>
-        /// <returns>The requested service interface, if it could be obtained; otherwise <see langword="null"/> if
-        /// <paramref name="throwOnFailure"/> is <see langword="false"/>.</returns>
-        /// <exception cref="ServiceUnavailableException">
-        /// Either the service could not be acquired, or the service does not support
-        /// the requested interface.
-        /// </exception>
-        public static async Task<TInterface?> GetServiceAsync<TService, TInterface>(
-            this IAsyncServiceProvider asyncServiceProvider,
-            JoinableTaskFactory joinableTaskFactory,
-            bool throwOnFailure)
-            where TInterface : class
-        {
-            Requires.NotNull(asyncServiceProvider, nameof(asyncServiceProvider));
-            object? service;
-
-            // Prefer IAsyncServiceProvider2 so that any original exceptions can be captured and included as an inner
-            // exception to the one that we throw.
-            if (throwOnFailure && asyncServiceProvider is IAsyncServiceProvider2 asyncServiceProvider2)
-            {
-                try
-                {
-                    service = await asyncServiceProvider2.GetServiceAsync(typeof(TService), swallowExceptions: false).ConfigureAwait(true);
-                }
-                catch (Exception ex)
-                {
-                    throw new ServiceUnavailableException(typeof(TService), ex);
-                }
-            }
-            else
-            {
-                service = await asyncServiceProvider.GetServiceAsync(typeof(TService)).ConfigureAwait(true);
-            }
-
-            if (service == null)
-            {
-                if (throwOnFailure)
-                    throw new ServiceUnavailableException(typeof(TService));
-
-                return null;
-            }
-
-            await joinableTaskFactory.SwitchToMainThreadAsync();
-
-            if (service is not TInterface @interface)
-            {
-                if (throwOnFailure)
-                    throw new ServiceUnavailableException(typeof(TInterface));
-
-                return null;
-            }
-
-            return @interface;
-        }
     }
 }
diff --git a/src/EditorFeatures/TestUtilities/StubVsServiceExporter`2.cs b/src/EditorFeatures/TestUtilities/StubVsServiceExporter`2.cs
index a5bd41a9f6ed0..34d32d140719f 100644
--- a/src/EditorFeatures/TestUtilities/StubVsServiceExporter`2.cs
+++ b/src/EditorFeatures/TestUtilities/StubVsServiceExporter`2.cs
@@ -34,7 +34,7 @@ public StubVsServiceExporter(
         [Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider2 asyncServiceProvider,
         JoinableTaskContext joinableTaskContext)
     {
-        _serviceGetter = new AsyncLazy<TInterface>(() => asyncServiceProvider.GetServiceAsync<TService, TInterface>(joinableTaskContext.Factory, throwOnFailure: true)!, joinableTaskContext.Factory);
+        _serviceGetter = new AsyncLazy<TInterface>(() => asyncServiceProvider.GetServiceAsync<TService, TInterface>(throwOnFailure: true, CancellationToken.None)!, joinableTaskContext.Factory);
     }
 
     /// <inheritdoc />
diff --git a/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs b/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs
index 8ac4ae72f868d..968126c0449c3 100644
--- a/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs
+++ b/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs
@@ -72,7 +72,7 @@ public void RegisterInitializationWork(PackageLoadTasks packageInitializationTas
 
     private async Task AfterPackageLoadedBackgroundThreadAsync(PackageLoadTasks afterPackageLoadedTasks, CancellationToken cancellationToken)
     {
-        var settingsManager = await _asyncServiceProvider.GetServiceAsync<SVsSettingsPersistenceManager, ISettingsManager>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
+        var settingsManager = await _asyncServiceProvider.GetServiceAsync<SVsSettingsPersistenceManager, ISettingsManager>(cancellationToken).ConfigureAwait(false);
 
         // We need to update the theme whenever the Editor Color Scheme setting changes.
         settingsManager.GetSubset(ColorSchemeOptionsStorage.ColorSchemeSettingKey).SettingChangedAsync += ColorSchemeChangedAsync;
diff --git a/src/VisualStudio/Core/Def/Diagnostics/VisualStudioDiagnosticAnalyzerService.cs b/src/VisualStudio/Core/Def/Diagnostics/VisualStudioDiagnosticAnalyzerService.cs
index 24e544c7dd1b0..6b6d18c62b945 100644
--- a/src/VisualStudio/Core/Def/Diagnostics/VisualStudioDiagnosticAnalyzerService.cs
+++ b/src/VisualStudio/Core/Def/Diagnostics/VisualStudioDiagnosticAnalyzerService.cs
@@ -62,7 +62,7 @@ public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, Cancell
         _serviceProvider = (IServiceProvider)serviceProvider;
 
         // Hook up the "Run Code Analysis" menu command for CPS based managed projects.
-        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         if (menuCommandService != null)
         {
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
diff --git a/src/VisualStudio/Core/Def/ProjectSystem/RuleSets/RuleSetEventHandler.cs b/src/VisualStudio/Core/Def/ProjectSystem/RuleSets/RuleSetEventHandler.cs
index 137cf1c364a41..59ad690c71f81 100644
--- a/src/VisualStudio/Core/Def/ProjectSystem/RuleSets/RuleSetEventHandler.cs
+++ b/src/VisualStudio/Core/Def/ProjectSystem/RuleSets/RuleSetEventHandler.cs
@@ -41,7 +41,7 @@ public async Task RegisterAsync(IAsyncServiceProvider serviceProvider, Cancellat
     {
         if (!_eventsHookedUp)
         {
-            var trackProjectDocuments = await serviceProvider.GetServiceAsync<SVsTrackProjectDocuments, IVsTrackProjectDocuments2>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
+            var trackProjectDocuments = await serviceProvider.GetServiceAsync<SVsTrackProjectDocuments, IVsTrackProjectDocuments2>(cancellationToken).ConfigureAwait(false);
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             if (!_eventsHookedUp)
diff --git a/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 27dc927d56ae0..faea52ad84722 100644
--- a/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -924,7 +924,7 @@ private bool TryAddEditorConfigToSolutionItems(
             return false;
 
         // All checks pass, so let's treat this special.
-        var dte = _threadingContext.JoinableTaskFactory.Run(() => _asyncServiceProvider.GetServiceAsync<SDTE, EnvDTE.DTE>(_threadingContext.JoinableTaskFactory));
+        var dte = _threadingContext.JoinableTaskFactory.Run(() => _asyncServiceProvider.GetServiceAsync<SDTE, EnvDTE.DTE>(_threadingContext.DisposalToken));
 
         const string SolutionItemsFolderName = "Solution Items";
 
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 054cd115e6fe3..464e92740c231 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -133,9 +133,9 @@ Task OnAfterPackageLoadedMainThreadAsync(PackageLoadTasks afterPackageLoadedTask
     private async Task ProfferServiceBrokerServicesAsync(CancellationToken cancellationToken)
     {
         // Proffer in-process service broker services
-        var serviceBrokerContainer = await this.GetServiceAsync<SVsBrokeredServiceContainer, IBrokeredServiceContainer>(throwOnFailure: true, cancellationToken).ConfigureAwait(false);
+        var serviceBrokerContainer = await this.GetServiceAsync<SVsBrokeredServiceContainer, IBrokeredServiceContainer>(cancellationToken).ConfigureAwait(false);
 
-        serviceBrokerContainer!.Proffer(
+        serviceBrokerContainer.Proffer(
             WorkspaceProjectFactoryServiceDescriptor.ServiceDescriptor,
             (_, _, _, _) => ValueTaskFactory.FromResult<object?>(new WorkspaceProjectFactoryService(this.ComponentModel.GetService<IWorkspaceProjectContextFactory>())));
 
@@ -172,7 +172,7 @@ protected override async Task LoadComponentsAsync(CancellationToken cancellation
 
         // we need to load it as early as possible since we can have errors from
         // package from each language very early
-        await this.ComponentModel.GetService<VisualStudioSuppressionFixService>().InitializeAsync(this).ConfigureAwait(false);
+        await this.ComponentModel.GetService<VisualStudioSuppressionFixService>().InitializeAsync(this, cancellationToken).ConfigureAwait(false);
         await this.ComponentModel.GetService<VisualStudioDiagnosticListSuppressionStateService>().InitializeAsync(this, cancellationToken).ConfigureAwait(false);
 
         await this.ComponentModel.GetService<IVisualStudioDiagnosticAnalyzerService>().InitializeAsync(this, cancellationToken).ConfigureAwait(false);
diff --git a/src/VisualStudio/Core/Def/SyncNamespaces/SyncNamespacesCommandHandler.cs b/src/VisualStudio/Core/Def/SyncNamespaces/SyncNamespacesCommandHandler.cs
index 42aa50a166bea..843302f2e9363 100644
--- a/src/VisualStudio/Core/Def/SyncNamespaces/SyncNamespacesCommandHandler.cs
+++ b/src/VisualStudio/Core/Def/SyncNamespaces/SyncNamespacesCommandHandler.cs
@@ -52,7 +52,7 @@ public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, Cancell
         _serviceProvider = (IServiceProvider)serviceProvider;
 
         // Hook up the "Remove Unused References" menu command for CPS based managed projects.
-        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         if (menuCommandService != null)
         {
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
diff --git a/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioDiagnosticListSuppressionStateService.cs b/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioDiagnosticListSuppressionStateService.cs
index 3056bfe21fb86..96d3210db2db8 100644
--- a/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioDiagnosticListSuppressionStateService.cs
+++ b/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioDiagnosticListSuppressionStateService.cs
@@ -58,8 +58,8 @@ public VisualStudioDiagnosticListSuppressionStateService(
 
     public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
-        _shellService = await serviceProvider.GetServiceAsync<SVsUIShell, IVsUIShell>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
-        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        _shellService = await serviceProvider.GetServiceAsync<SVsUIShell, IVsUIShell>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
+        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         _tableControl = errorList?.TableControl;
 
         await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
diff --git a/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs b/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs
index fee24235192ab..d2dc51bafb98d 100644
--- a/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs
+++ b/src/VisualStudio/Core/Def/TableDataSource/Suppression/VisualStudioSuppressionFixService.cs
@@ -64,9 +64,9 @@ internal sealed class VisualStudioSuppressionFixService(
 
     private IWpfTableControl? _tableControl;
 
-    public async Task InitializeAsync(IAsyncServiceProvider serviceProvider)
+    public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
-        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var errorList = await serviceProvider.GetServiceAsync<SVsErrorList, IErrorList>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         _tableControl = errorList?.TableControl;
     }
 
diff --git a/src/VisualStudio/Core/Def/UnusedReferences/RemoveUnusedReferencesCommandHandler.cs b/src/VisualStudio/Core/Def/UnusedReferences/RemoveUnusedReferencesCommandHandler.cs
index 1a78d42e1f6a4..f14eb4eae481a 100644
--- a/src/VisualStudio/Core/Def/UnusedReferences/RemoveUnusedReferencesCommandHandler.cs
+++ b/src/VisualStudio/Core/Def/UnusedReferences/RemoveUnusedReferencesCommandHandler.cs
@@ -65,7 +65,7 @@ public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, Cancell
         _serviceProvider = (IServiceProvider)serviceProvider;
 
         // Hook up the "Remove Unused References" menu command for CPS based managed projects.
-        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        var menuCommandService = await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         if (menuCommandService != null)
         {
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
diff --git a/src/VisualStudio/Core/Def/Workspace/VisualStudioSourceGeneratorTelemetryCollectorWorkspaceServiceFactory.cs b/src/VisualStudio/Core/Def/Workspace/VisualStudioSourceGeneratorTelemetryCollectorWorkspaceServiceFactory.cs
index ed8d55d30d282..c0dfd40cc2081 100644
--- a/src/VisualStudio/Core/Def/Workspace/VisualStudioSourceGeneratorTelemetryCollectorWorkspaceServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Workspace/VisualStudioSourceGeneratorTelemetryCollectorWorkspaceServiceFactory.cs
@@ -73,7 +73,7 @@ private void EnsureSubscribedToSolutionEvents()
         {
             Task.Run(async () =>
             {
-                var shellService = await _serviceProvider.GetServiceAsync<SVsSolution, IVsSolution>(_threadingContext.JoinableTaskFactory).ConfigureAwait(true);
+                var shellService = await _serviceProvider.GetServiceAsync<SVsSolution, IVsSolution>(_threadingContext.DisposalToken).ConfigureAwait(true);
                 await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
                 shellService.AdviseSolutionEvents(this, out _);
             }, _threadingContext.DisposalToken);
diff --git a/src/VisualStudio/Core/Def/Workspace/VisualStudioWorkspaceStatusServiceFactory.cs b/src/VisualStudio/Core/Def/Workspace/VisualStudioWorkspaceStatusServiceFactory.cs
index 5d4eed5781bde..2c68285daff7c 100644
--- a/src/VisualStudio/Core/Def/Workspace/VisualStudioWorkspaceStatusServiceFactory.cs
+++ b/src/VisualStudio/Core/Def/Workspace/VisualStudioWorkspaceStatusServiceFactory.cs
@@ -77,8 +77,7 @@ public Service(IAsyncServiceProvider2 serviceProvider, IThreadingContext threadi
                 await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, _threadingContext.DisposalToken);
 
                 // Make sure the HubClient package is loaded, since we rely on it for proffered OOP services
-                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(_threadingContext.JoinableTaskFactory).ConfigureAwait(true);
-                Assumes.Present(shell);
+                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(_threadingContext.DisposalToken).ConfigureAwait(true);
 
                 await shell.LoadPackageAsync(Guids.GlobalHubClientPackageGuid);
             });
@@ -90,7 +89,7 @@ public Service(IAsyncServiceProvider2 serviceProvider, IThreadingContext threadi
                 using var asyncToken = listener.BeginAsyncOperation("StatusChanged_EventSubscription");
 
                 await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, _threadingContext.DisposalToken);
-                var service = await serviceProvider.GetServiceAsync<SVsOperationProgress, IVsOperationProgressStatusService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(true);
+                var service = await serviceProvider.GetServiceAsync<SVsOperationProgress, IVsOperationProgressStatusService>(throwOnFailure: false, _threadingContext.DisposalToken).ConfigureAwait(true);
                 if (service is null)
                     return null;
 
diff --git a/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProjectFactory.cs b/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProjectFactory.cs
index 9dd9945d9b718..73fe05a2e3276 100644
--- a/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProjectFactory.cs
+++ b/src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProjectFactory.cs
@@ -165,7 +165,7 @@ public async Task<IWorkspaceProjectContext> CreateProjectContextAsync(Guid id, s
             {
                 await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(_threadingContext.JoinableTaskFactory).ConfigureAwait(true);
+                var shell = await _serviceProvider.GetServiceAsync<SVsShell, IVsShell7>(cancellationToken).ConfigureAwait(true);
 
                 // Force the F# package to load; this is necessary because the F# package listens to WorkspaceChanged to 
                 // set up some items, and the F# project system doesn't guarantee that the F# package has been loaded itself
diff --git a/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerItemTracker.cs b/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerItemTracker.cs
index bd18f54329276..218973ee31bfd 100644
--- a/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerItemTracker.cs
+++ b/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerItemTracker.cs
@@ -34,7 +34,7 @@ internal sealed class AnalyzerItemsTracker(IThreadingContext threadingContext) :
 
     public async Task RegisterAsync(IAsyncServiceProvider serviceProvider, CancellationToken cancellationToken)
     {
-        _vsMonitorSelection ??= await serviceProvider.GetServiceAsync<SVsShellMonitorSelection, IVsMonitorSelection>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false);
+        _vsMonitorSelection ??= await serviceProvider.GetServiceAsync<SVsShellMonitorSelection, IVsMonitorSelection>(throwOnFailure: false, cancellationToken).ConfigureAwait(false);
         await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
         _vsMonitorSelection?.AdviseSelectionEvents(this, out _selectionEventsCookie);
     }
diff --git a/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerNodeSetup.cs b/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerNodeSetup.cs
index 76729d0e538b5..4c098a9765035 100644
--- a/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerNodeSetup.cs
+++ b/src/VisualStudio/Core/Impl/SolutionExplorer/AnalyzerNodeSetup.cs
@@ -7,7 +7,6 @@
 using System.ComponentModel.Design;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.VisualStudio.Shell;
 
@@ -16,18 +15,15 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.SolutionExplore
     [Export(typeof(IAnalyzerNodeSetup))]
     internal sealed class AnalyzerNodeSetup : IAnalyzerNodeSetup
     {
-        private readonly IThreadingContext _threadingContext;
         private readonly AnalyzerItemsTracker _analyzerTracker;
         private readonly AnalyzersCommandHandler _analyzerCommandHandler;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public AnalyzerNodeSetup(
-            IThreadingContext threadingContext,
             AnalyzerItemsTracker analyzerTracker,
             AnalyzersCommandHandler analyzerCommandHandler)
         {
-            _threadingContext = threadingContext;
             _analyzerTracker = analyzerTracker;
             _analyzerCommandHandler = analyzerCommandHandler;
         }
@@ -36,7 +32,7 @@ public async Task InitializeAsync(IAsyncServiceProvider serviceProvider, Cancell
         {
             await _analyzerTracker.RegisterAsync(serviceProvider, cancellationToken).ConfigureAwait(false);
             await _analyzerCommandHandler.InitializeAsync(
-                await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(_threadingContext.JoinableTaskFactory, throwOnFailure: false).ConfigureAwait(false),
+                await serviceProvider.GetServiceAsync<IMenuCommandService, IMenuCommandService>(throwOnFailure: false, cancellationToken).ConfigureAwait(false),
                 cancellationToken).ConfigureAwait(false);
         }