Services

IncrementalAnalyzerRunner.cs (4)

43var exportProvider = _workspace.Services.SolutionServices.ExportProvider; 49var workspaceConfigurationService = (AnalyzerRunnerWorkspaceConfigurationService)_workspace.Services.GetRequiredService<IWorkspaceConfigurationService>(); 52var solutionCrawlerRegistrationService = (SolutionCrawlerRegistrationService)_workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>(); 57var persistentStorageService = _workspace.Services.SolutionServices.GetPersistentStorageService();

FormatterBenchmarks.cs (2)

50return Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None); 63return Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None);

FindReferencesBenchmarks.cs (1)

94var storageService = _workspace.Services.SolutionServices.GetPersistentStorageService();

NavigateToBenchmarks.cs (1)

196var storageService = _workspace.Services.SolutionServices.GetPersistentStorageService();

ProjectExtensions.cs (1)

37=> project.Solution.Workspace.Services.GetExtendedLanguageServices(project.Language);

CodeActions\Preview\PreviewExceptionTests.cs (3)

33var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService<IErrorReportingService>(); 46var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService<IErrorReportingService>(); 59var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService<IErrorReportingService>();

Completion\CompletionProviders\LoadDirectiveCompletionProviderTests.cs (1)

82var languageServices = workspace.Services.GetLanguageServices(LanguageNames.CSharp);

Completion\CompletionProviders\ReferenceDirectiveCompletionProviderTests.cs (1)

119var languageServices = workspace.Services.GetLanguageServices(LanguageNames.CSharp);

EditorConfigSettings\Updater\SettingsUpdaterTests.cs (2)

49=> workspace.Services.SolutionServices.ExportProvider.GetExportedValue<IGlobalOptionService>(); 400var settingsProviderFactory = workspace.Services.GetRequiredService<IWorkspaceSettingsProviderFactory<NamingStyleSetting>>();

EncapsulateField\EncapsulateFieldTestState.cs (1)

37var notificationService = Workspace.Services.GetService<INotificationService>() as INotificationServiceCallback;

ExtractMethod\MiscTests.cs (1)

135var callBackService = workspace.Services.GetService<INotificationService>() as INotificationServiceCallback;

Formatting\FormattingEngineTests.cs (2)

421var node = Formatter.Format(syntaxRoot, spans, workspace.Services.SolutionServices, options, rules: null, CancellationToken.None); 2326var formattedRoot = Formatter.Format(root, workspace.Services.SolutionServices, options, CancellationToken.None);

Formatting\Indentation\CSharpFormatterTestsBase.cs (2)

87var formattingRuleProvider = workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>(); 116var factory = (TestFormattingRuleFactoryServiceFactory.Factory)workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>();

Formatting\Indentation\SmartIndenterTests.cs (1)

3487var provider = (TestFormattingRuleFactoryServiceFactory.Factory)workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>();

GenerateFromMembers\GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersTests.cs (1)

45var service = (TestPickMembersService)workspace.Services.GetService<IPickMembersService>();

LineSeparators\LineSeparatorTests.cs (1)

542var lineSeparatorService = Assert.IsType<CSharpLineSeparatorService>(workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService<ILineSeparatorService>());

MoveStaticMembers\CSharpMoveStaticMembersTests.cs (1)

3428var testOptionsService = (TestMoveStaticMembersService)workspace.Services.GetRequiredService<IMoveStaticMembersOptionsService>();

StringCopyPaste\StringCopyPasteCommandHandlerTests.cs (1)

91var service = workspace.Services.GetRequiredService<IStringCopyPasteService>() as TestStringCopyPasteService;

Workspaces\WorkspaceTests_EditorFeatures.cs (1)

568var trackingService = (TestDocumentTrackingService)workspace.Services.GetRequiredService<IDocumentTrackingService>();

CodeGeneration\SyntaxGeneratorTests.cs (1)

4481var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, _workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None).ToFullString();

Formatting\FormattingElasticTriviaTests.cs (5)

94var newCompilation = Formatter.Format(compilation, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 134var formatted = Formatter.Format(newRoot, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString(); 137var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString(); 140var annotationFormatted = Formatter.Format(newRoot, Formatter.Annotation, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString(); 195var newCompilation = Formatter.Format(compilation, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

Formatting\FormattingMultipleSpanTests.cs (1)

169var result = Formatter.Format(root, TextSpan.FromBounds(0, 0), workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

Formatting\FormattingTests.cs (3)

4527var newProperty = Formatter.Format(property, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 8111Formatter.Format(block, new AdhocWorkspace().Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 9151=> Formatter.Format(SyntaxFactory.StructDeclaration("S"), DefaultWorkspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

Formatting\FormattingTriviaTests.cs (2)

1752var formatted = Formatter.Format(tree, workspace.Services.SolutionServices, options, CancellationToken.None); 1798var formatted = Formatter.Format(tree, workspace.Services.SolutionServices, options, CancellationToken.None);

ChangeSignature\AbstractChangeSignatureCommandHandler.cs (2)

109var notificationService = workspace.Services.GetRequiredService<INotificationService>(); 127var previewService = workspace.Services.GetService<IPreviewDialogService>();

Classification\Syntactic\SyntacticClassificationTaggerProvider.TagComputer.cs (1)

113=> _workspace?.Services.SolutionServices.GetProjectServices(snapshot.ContentType)?.GetService<IClassificationService>();

CodeActions\CodeActionEditHandlerService.cs (5)

123workspace.Services.GetService<INotificationService>()?.SendNotification( 147using (workspace.Services.GetRequiredService<ISourceTextUndoService>().RegisterUndoTransaction(text, title)) 309var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>(); 327var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>(); 351var navigationService = editorWorkspace.Services.GetRequiredService<IDocumentNavigationService>();

CodeDefinitionWindow\DefinitionContextTracker.cs (2)

167var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>(); 200var symbolNavigationService = workspace.Services.GetRequiredService<ISymbolNavigationService>();

Diagnostics\AbstractPushOrPullDiagnosticsTaggerProvider.PushDiagnosticsTaggerProvider.cs (1)

77&& e.Workspace.Services.GetService<IWorkspaceConfigurationService>()?.Options.EnableOpeningSourceGeneratedFiles == true

EditAndContinue\ActiveStatementTaggerProvider.EventSource.cs (2)

21var trackingService = workspace.Services.GetService<IActiveStatementTrackingService>(); 31var trackingService = workspace.Services.GetService<IActiveStatementTrackingService>();

EditAndContinue\ActiveStatementTrackingService.cs (1)

121_compileTimeSolutionProvider = workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>();

EditAndContinue\EditAndContinueDiagnosticAnalyzer.cs (3)

58if (workspace.Services.HostServices is not IMefHostExportProvider mefServices) 70var compileTimeSolution = workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>().GetCompileTimeSolution(designTimeSolution); 84var trackingService = workspace.Services.GetRequiredService<IActiveStatementTrackingService>();

EditAndContinue\EditAndContinueLanguageService.cs (2)

84return workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>().GetCompileTimeSolution(currentDesignTimeSolution ?? workspace.CurrentSolution); 95=> WorkspaceProvider.Value.Workspace.Services.GetRequiredService<IActiveStatementTrackingService>();

EditorConfigSettings\Aggregator\SettingsAggregator.cs (2)

81var commonProvider = workspace.Services.GetRequiredService<IWorkspaceSettingsProviderFactory<T>>(); 100var provider = workspace.Services.GetLanguageServices(language).GetService<ILanguageSettingsProviderFactory<T>>();

EditorConfigSettings\Updater\SettingsUpdaterBase.cs (1)

29_listener = workspace.Services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>().GetListener();

EncapsulateField\AbstractEncapsulateFieldCommandHandler.cs (3)

80var indicatorFactory = workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 103var notificationService = workspace.Services.GetRequiredService<INotificationService>(); 120var previewService = workspace.Services.GetService<IPreviewDialogService>();

Extensibility\NavigationBar\AbstractEditorNavigationBarItemService.cs (2)

58var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>(); 65var notificationService = workspace.Services.GetRequiredService<INotificationService>();

ExternalAccess\VSTypeScript\VSTypeScriptNavigationBarItemService.cs (1)

66var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();

ExtractInterface\AbstractExtractInterfaceCommandHandler.cs (2)

77(errorMessage, severity) => workspace.Services.GetService<INotificationService>().SendNotification(errorMessage, severity: severity), 91var navigationService = workspace.Services.GetService<IDocumentNavigationService>();

GoToDefinition\AbstractGoToDefinitionService.cs (1)

40var service = workspace.Services.GetRequiredService<IDocumentNavigationService>();

InlineRename\CommandHandlers\AbstractRenameCommandHandler_RenameHandler.cs (2)

69var backgroundWorkIndicatorFactory = workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 134var notificationService = workspace.Services.GetService<INotificationService>();

InlineRename\InlineRenameService.cs (1)

142var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();

InlineRename\InlineRenameSession.cs (4)

184this.UndoManager = workspace.Services.GetService<IInlineRenameUndoManager>(); 782var factory = _workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 824var previewService = _workspace.Services.GetService<IPreviewDialogService>(); 856var notificationService = _workspace.Services.GetService<INotificationService>();

InlineRename\UndoManagerServiceFactory.cs (1)

53var textUndoHistoryService = workspace.Services.GetService<ITextUndoHistoryWorkspaceService>();

IntelliSense\QuickInfo\QuickInfoHyperLink.cs (1)

44var navigateToLinkService = _workspace.Services.GetRequiredService<INavigateToLinkService>();

Interactive\InteractiveSession.cs (2)

187var metadataService = _workspace.Services.GetRequiredService<IMetadataService>(); 283var metadataService = _workspace.Services.GetRequiredService<IMetadataService>();

Interactive\InteractiveWorkspace.cs (2)

25Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Register(this); 32Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Unregister(this, blockingShutdown: true);

NavigateTo\NavigateToHelpers.cs (1)

39var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();

Organizing\OrganizeDocumentCommandHandler.cs (1)

87var organizeImportsService = workspace.Services.SolutionServices.GetProjectServices(args.SubjectBuffer).GetService<IOrganizeImportsService>();

Remote\SolutionChecksumUpdater.cs (1)

53_globalOperationService = workspace.Services.SolutionServices.ExportProvider.GetExports<IGlobalOperationNotificationService>().FirstOrDefault()?.Value;

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCodeAction.cs (1)

128var notificationService = workspace.Services.GetService<INotificationService>();

Shared\Extensions\HostWorkspaceServicesExtensions.cs (1)

46workspace.Services.SolutionServices.GetProjectServices(buffer.ContentType)?.Language : null;

Shared\Extensions\ITextBufferExtensions.cs (2)

20var workspaceContextService = workspace.Services.GetRequiredService<IWorkspaceContextService>(); 59service = workspace.Services.GetService<ITextBufferSupportsFeatureService>();

Shared\Preview\PreviewWorkspace.cs (3)

28: base(solution.Workspace.Services.HostServices, WorkspaceKind.Preview) 37Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Register(this); 110Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Unregister(this);

SolutionCrawler\HostSolutionCrawlerWorkspaceEventListener.cs (2)

29workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Register(workspace); 37var registration = workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>();

SolutionEvents\HostLegacySolutionEventsWorkspaceEventListener.cs (2)

72var aggregationService = workspace.Services.GetRequiredService<ILegacySolutionEventsAggregationService>(); 73var shouldReport = aggregationService.ShouldReportChanges(workspace.Services.SolutionServices);

Undo\Extensions.cs (1)

19var undoService = workspace.Services.GetService<IGlobalUndoService>();

AsyncSuggestedActionsSource.cs (2)

90await workspace.Services.GetRequiredService<IWorkspaceStatusService>().WaitUntilFullyLoadedAsync(cancellationToken).ConfigureAwait(false); 177var supportsFeatureService = workspace.Services.GetRequiredService<ITextBufferSupportsFeatureService>();

FixAllGetFixesService.cs (1)

191var previewService = workspace.Services.GetService<IPreviewDialogService>();

FixMultipleOccurrencesService.cs (1)

85var extensionManager = workspace.Services.GetService<IExtensionManager>();

PreviewChangesCodeAction.cs (1)

37var previewDialogService = _workspace.Services.GetService<IPreviewDialogService>();

SuggestedAction.cs (2)

136await Workspace.Services.GetService<IExtensionManager>().PerformActionAsync( 211var extensionManager = Workspace.Services.GetService<IExtensionManager>();

SuggestedActionsSource.cs (3)

151var statusService = state.Target.Workspace.Services.GetRequiredService<IWorkspaceStatusService>(); 166var supportsFeatureService = workspace.Services.GetRequiredService<ITextBufferSupportsFeatureService>(); 526if (!await workspace.Services.GetRequiredService<IWorkspaceStatusService>().IsFullyLoadedAsync(cancellationToken).ConfigureAwait(false))

SuggestedActionWithNestedFlavors.cs (3)

72var extensionManager = this.Workspace.Services.GetService<IExtensionManager>(); 132var previewPaneService = Workspace.Services.GetService<IPreviewPaneService>(); 143var extensionManager = this.Workspace.Services.GetService<IExtensionManager>();

ChangeSignature\AbstractChangeSignatureTests.cs (1)

54var optionsService = (TestChangeSignatureOptionsService)workspace.Services.GetRequiredService<IChangeSignatureOptionsService>();

CodeActions\AbstractCodeActionOrUserDiagnosticTest.cs (1)

171var remoteHostProvider = (InProcRemoteHostClientProvider)workspace.Services.GetRequiredService<IRemoteHostClientProvider>();

AbstractCommandHandlerTestState.cs (1)

73var contentType = Workspace.Services.GetLanguageServices(languageName).GetRequiredService<IContentTypeLanguageService>().GetDefaultContentType();

Completion\AbstractArgumentProviderTests`1.cs (1)

103var syntaxFacts = workspace.Services.GetLanguageServices(root.Language).GetRequiredService<ISyntaxFactsService>();

Diagnostics\DiagnosticTaggerWrapper.cs (1)

55_registrationService = (SolutionCrawlerRegistrationService)workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>();

Diagnostics\TestDiagnosticAnalyzerDriver.cs (1)

37var mefServices = workspace.Services.SolutionServices.ExportProvider;

Formatting\CoreFormatterTestsBase.cs (6)

98if (workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>() is TestFormattingRuleFactoryServiceFactory.Factory factory && factory.BaseIndentation != 0 && factory.TextSpan.Contains(p.Position)) 193var formattingRuleProvider = workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>(); 216var newRootNode = Formatter.Format(root, spans, workspace.Services.SolutionServices, options, rules, CancellationToken.None); 229var result = Formatter.GetFormattedTextChanges(root, spans, workspace.Services.SolutionServices, options, rules, CancellationToken.None); 289var formattingService = workspace.Services.GetLanguageServices(node.Language).GetRequiredService<ISyntaxFormattingService>(); 291var result = Formatter.Format(node, workspace.Services.SolutionServices, options, CancellationToken.None);

LanguageServer\AbstractLanguageServerProtocolTests.cs (3)

377var solutionCrawlerRegistrationService = (SolutionCrawlerRegistrationService)workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>(); 590workspace.Services.HostServices, 695var solutionCrawlerRegistrationService = (SolutionCrawlerRegistrationService)TestWorkspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>();

Workspaces\TestHostProject.cs (1)

239_languageServices = workspace.Services.GetLanguageServices(language);

Workspaces\TestWorkspace.cs (2)

75var partialSolutionsTestHook = Services.GetRequiredService<IWorkpacePartialSolutionsTestHook>(); 98if (Services.GetService<INotificationService>() is INotificationServiceCallback callback)

Workspaces\TestWorkspace_XmlConsumption.cs (8)

228var languageServices = Services.GetLanguageServices(languageName); 250var metadataService = Services.GetService<IMetadataService>(); 313var languageServices = workspace.Services.GetLanguageServices(language); 529if (!workspace.Services.SupportedLanguages.Contains(languageName)) 532string.Join(", ", workspace.Services.SupportedLanguages), 676var languageServices = workspace.Services.GetLanguageServices(language); 677var metadataService = workspace.Services.GetService<IMetadataService>(); 963var languageServices = workspace.Services.GetLanguageServices(languageName);

CodeFixes\CodeFixServiceTests.cs (4)

53var logger = SpecializedCollections.SingletonEnumerable(new Lazy<IErrorLoggerService>(() => workspace.Services.GetRequiredService<IErrorLoggerService>())); 260var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService<IErrorReportingService>(); 289var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService<IErrorReportingService>(); 699var logger = SpecializedCollections.SingletonEnumerable(new Lazy<IErrorLoggerService>(() => workspace.Services.GetRequiredService<IErrorLoggerService>()));

CodeGeneration\AbstractCodeGenerationTests.cs (2)

81var codeDefFactory = workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService<SyntaxGenerator>(); 102var codeDefFactory = workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService<SyntaxGenerator>();

CodeRefactorings\CodeRefactoringServiceTest.cs (1)

107var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService<IErrorReportingService>();

Diagnostics\DiagnosticAnalyzerServiceTests.cs (16)

EditAndContinue\CompileTimeSolutionProviderTests.cs (2)

63var provider = workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>(); 130var provider = workspace.Services.GetRequiredService<ICompileTimeSolutionProvider>();

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (4)

166var service = (EditAndContinueWorkspaceService)workspace.Services.GetRequiredService<IEditAndContinueWorkspaceService>(); 4570var hotReload = new WatchHotReloadService(workspace.Services, ImmutableArray.Create("Baseline", "AddDefinitionToExistingType", "NewTypeDefinition")); 4637var hotReload = new UnitTestingHotReloadService(workspace.Services); 4699loader: new WorkspaceFileTextLoader(workspace.Services.SolutionServices, sourceFile.Path, Encoding.UTF8),

EditAndContinue\RemoteEditAndContinueServiceTests.cs (3)

61var clientProvider = (InProcRemoteHostClientProvider?)localWorkspace.Services.GetService<IRemoteHostClientProvider>(); 66mockEncService = (MockEditAndContinueWorkspaceService)localWorkspace.Services.GetRequiredService<IEditAndContinueWorkspaceService>(); 75mockEncService = (MockEditAndContinueWorkspaceService)remoteWorkspace.Services.GetRequiredService<IEditAndContinueWorkspaceService>();

EditorConfigSettings\Data\CodeStyleSettingsTest.cs (1)

22=> workspace.Services.SolutionServices.ExportProvider.GetExportedValue<IGlobalOptionService>();

Options\GlobalOptionsTests.cs (1)

181var languageServices = workspace.Services.SolutionServices.GetLanguageServices(language);

Preview\PreviewWorkspaceTests.cs (2)

127var service = previewWorkspace.Services.GetService<ISolutionCrawlerRegistrationService>(); 131var persistentService = previewWorkspace.Services.SolutionServices.GetPersistentStorageService();

RenameTracking\RenameTrackingTestState.cs (1)

98var notificationService = (INotificationServiceCallback)Workspace.Services.GetRequiredService<INotificationService>();

SolutionCrawler\WorkCoordinatorTests.cs (15)

StackTraceExplorer\StackTraceExplorerTests.cs (3)

41var service = workspace.Services.GetRequiredService<IStackTraceExplorerService>(); 826var service = workspace.Services.GetRequiredService<IStackTraceExplorerService>(); 858var service = workspace.Services.GetRequiredService<IStackTraceExplorerService>();

ValueTracking\AbstractBaseValueTrackingTests.cs (2)

32var service = testWorkspace.Services.GetRequiredService<IValueTrackingService>(); 39var service = testWorkspace.Services.GetRequiredService<IValueTrackingService>();

Workspaces\DefaultMefHostTests.cs (2)

26var csservice = ws.Services.GetLanguageServices(LanguageNames.CSharp).GetService<Microsoft.CodeAnalysis.Completion.CompletionService>(); 29var vbservice = ws.Services.GetLanguageServices(LanguageNames.VisualBasic).GetService<Microsoft.CodeAnalysis.Completion.CompletionService>();

Workspaces\TextFactoryTests.cs (6)

28var textFactoryService = Assert.IsType<EditorTextFactoryService>(workspace.Services.GetRequiredService<ITextFactoryService>()); 41var textFactoryService = Assert.IsType<EditorTextFactoryService>(workspace.Services.GetRequiredService<ITextFactoryService>()); 54var textFactoryService = Assert.IsType<EditorTextFactoryService>(workspace.Services.GetRequiredService<ITextFactoryService>()); 67var textFactoryService = Assert.IsType<EditorTextFactoryService>(workspace.Services.GetRequiredService<ITextFactoryService>()); 81var temporaryStorageService = Assert.IsType<TemporaryStorageService>(workspace.Services.GetRequiredService<ITemporaryStorageServiceInternal>()); 103var temporaryStorageService = Assert.IsType<TemporaryStorageService>(workspace.Services.GetRequiredService<ITemporaryStorageServiceInternal>());

InlineDiagnostics\InlineDiagnosticsTaggerProvider.cs (1)

95var navigateService = workspace.Services.GetRequiredService<INavigateToLinkService>();

InlineRename\CommandHandlers\RenameCommandHandler.cs (2)

112var notificationService = activeSession.Workspace.Services.GetService<INotificationService>(); 118var errorReportingService = activeSession.Workspace.Services.GetService<IErrorReportingService>();

InlineRename\UI\Dashboard\RenameDashboard.xaml.cs (2)

343var notificationService = _model.Session.Workspace.Services.GetService<INotificationService>(); 349var errorReportingService = _model.Session.Workspace.Services.GetService<IErrorReportingService>();

NavigateTo\NavigateToItemDisplay.cs (2)

118var previewService = workspace.Services.GetService<INavigateToPreviewService>(); 132var previewService = workspace.Services.GetService<INavigateToPreviewService>();

Peek\PeekableItemSource.cs (1)

131var navigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();

Peek\PeekHelpers.cs (1)

53var syntaxFactsService = workspace.Services.GetLanguageServices(root.Language).GetService<ISyntaxFactsService>();

QuickInfo\Extensions.cs (1)

23var cloneServices = workspace.Services.SolutionServices.ExportProvider.GetExports<ITextBufferCloneService>();

Suggestions\AsyncSuggestedActionsSource.cs (2)

90await workspace.Services.GetRequiredService<IWorkspaceStatusService>().WaitUntilFullyLoadedAsync(cancellationToken).ConfigureAwait(false); 177var supportsFeatureService = workspace.Services.GetRequiredService<ITextBufferSupportsFeatureService>();

Suggestions\FixAll\FixAllGetFixesService.cs (1)

198var previewService = workspace.Services.GetRequiredService<IPreviewDialogService>();

Suggestions\FixAll\FixMultipleOccurrencesService.cs (1)

85var extensionManager = workspace.Services.GetService<IExtensionManager>();

Suggestions\PreviewChanges\PreviewChangesCodeAction.cs (1)

37var previewDialogService = _workspace.Services.GetService<IPreviewDialogService>();

Suggestions\SuggestedActions\SuggestedAction.cs (2)

136await Workspace.Services.GetService<IExtensionManager>().PerformActionAsync( 211var extensionManager = Workspace.Services.GetService<IExtensionManager>();

Suggestions\SuggestedActionsSource.cs (3)

151var statusService = state.Target.Workspace.Services.GetRequiredService<IWorkspaceStatusService>(); 166var supportsFeatureService = workspace.Services.GetRequiredService<ITextBufferSupportsFeatureService>(); 526if (!await workspace.Services.GetRequiredService<IWorkspaceStatusService>().IsFullyLoadedAsync(cancellationToken).ConfigureAwait(false))

Suggestions\SuggestedActionWithNestedFlavors.cs (3)

72var extensionManager = this.Workspace.Services.GetService<IExtensionManager>(); 132var previewPaneService = Workspace.Services.GetService<IPreviewPaneService>(); 143var extensionManager = this.Workspace.Services.GetService<IExtensionManager>();

CodeFixes\CodeFixServiceTests.vb (2)

60Dim logger = SpecializedCollections.SingletonEnumerable(New Lazy(Of IErrorLoggerService)(Function() workspace.Services.GetService(Of IErrorLoggerService))) 139Dim logger = SpecializedCollections.SingletonEnumerable(New Lazy(Of IErrorLoggerService)(Function() workspace.Services.GetService(Of IErrorLoggerService)))

Diagnostics\AbstractCrossLanguageUserDiagnosticTest.vb (1)

67workspace.Services.SolutionServices.SetWorkspaceTestOutput(_outputHelper)

Diagnostics\AddImport\AddImportCrossLanguageTests.vb (1)

457workspace.Services.GetRequiredService(Of ISymbolTreeInfoCacheService),

Diagnostics\DiagnosticProviderTests.vb (2)

266Dim registrationService = workspace.Services.GetService(Of ISolutionCrawlerRegistrationService)() 299Dim service = DirectCast(workspace.Services.GetService(Of ISolutionCrawlerRegistrationService)(), SolutionCrawlerRegistrationService)

Diagnostics\DiagnosticServiceTests.vb (28)

FindReferences\FindReferencesTests.vb (1)

280workspace.Services.SolutionServices.SetWorkspaceTestOutput(_outputHelper)

GoToDefinition\GoToDefinitionCommandHandlerTests.vb (3)

56DirectCast(workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationService) 98DirectCast(workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationService) 143DirectCast(workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationService)

GoToDefinition\GoToDefinitionTestsBase.vb (2)

37Dim mockDocumentNavigationService = DirectCast(workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationService) 38Dim mockSymbolNavigationService = DirectCast(workspace.Services.GetService(Of ISymbolNavigationService)(), MockSymbolNavigationService)

IntelliSense\AbstractIntellisenseQuickInfoBuilderTests.vb (1)

69Dim languageServiceProvider = workspace.Services.GetLanguageServices(language)

IntelliSense\CompletionServiceTests.vb (1)

37Dim completionService = New TestCompletionService(workspace.Services.SolutionServices, workspace.GetService(Of IAsynchronousOperationListenerProvider)())

IntelliSense\CompletionServiceTests_Exclusivitiy.vb (1)

42Dim completionService = New TestCompletionService(workspace.Services.SolutionServices)

IntelliSense\CSharpCompletionCommandHandlerTests.vb (22)

IntelliSense\VisualBasicCompletionCommandHandlerTests.vb (3)

412Dim completionService = state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService(Of CompletionService)() 450Dim completionService = state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService(Of CompletionService)() 484Dim completionService = state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService(Of CompletionService)()

NavigableSymbols\NavigableSymbolsTest.vb (1)

141Dim navigationService = DirectCast(workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationServiceProvider.MockDocumentNavigationService)

Rename\InlineRenameTests.vb (3)

1096Dim previewService = DirectCast(workspace.Services.GetRequiredService(Of IPreviewDialogService)(), MockPreviewDialogService) 1135Dim previewService = DirectCast(workspace.Services.GetService(Of IPreviewDialogService)(), MockPreviewDialogService) 1292Dim notificationService = DirectCast(workspace.Services.GetService(Of INotificationService)(), INotificationServiceCallback)

Rename\RenameEngineResult.vb (1)

70workspace.Services.SolutionServices.SetWorkspaceTestOutput(helper)

Rename\RenameNonRenameableSymbols.vb (1)

401Dim navigationService = DirectCast(workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationService)

Workspaces\SymbolDescriptionServiceTests.vb (1)

54Return workspace.Services.GetLanguageServices(language)

Workspaces\TryFindSourceDefinitionTests.vb (1)

27workspace.Services.SolutionServices.SetWorkspaceTestOutput(_outputHelper)

Completion\FSharpCompletionServiceWithProviders.cs (1)

15: base(workspace.Services.SolutionServices, AsynchronousOperationListenerProvider.NullProvider)

Internal\Editor\FSharpNavigationBarItemService.cs (2)

70var navigationService = workspace.Services.GetRequiredService<IFSharpDocumentNavigationService>(); 80var notificationService = workspace.Services.GetRequiredService<INotificationService>();

LanguageServices\FSharpVisualStudioWorkspaceExtensions.cs (1)

17var metadataReferenceProvider = workspace.Services.GetRequiredService<VisualStudioMetadataReferenceManager>();

Navigation\FSharpDocumentNavigationService.cs (6)

37var service = workspace.Services.GetService<IDocumentNavigationService>(); 48var service = workspace.Services.GetService<IDocumentNavigationService>(); 59var service = workspace.Services.GetService<IDocumentNavigationService>(); 70var service = workspace.Services.GetService<IDocumentNavigationService>(); 82var service = workspace.Services.GetService<IDocumentNavigationService>(); 94var service = workspace.Services.GetService<IDocumentNavigationService>();

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (2)

102var service = workspace.Services.GetRequiredService<IMetadataService>(); 112var assemblyResolverService = workspace.Services.GetRequiredService<IFrameworkAssemblyPathResolver>();

ChangeSignature\ChangeSignatureCodeActionOperation.cs (1)

47var notificationService = workspace.Services.GetRequiredService<INotificationService>();

DocumentSpanExtensions.cs (1)

18var service = workspace.Services.GetRequiredService<IDocumentNavigationService>();

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (3)

39=> _workspace.Services.GetRequiredService<IEditAndContinueWorkspaceService>(); 212var client = await RemoteHostClient.TryGetClientAsync(_workspace.Services.SolutionServices, cancellationToken).ConfigureAwait(false); 229var client = await RemoteHostClient.TryGetClientAsync(_workspace.Services.SolutionServices, cancellationToken).ConfigureAwait(false);

EditAndContinue\Remote\RemoteEditAndContinueServiceProxy.cs (1)

136=> Workspace.Services.GetRequiredService<IEditAndContinueWorkspaceService>();

ExternalAccess\UnitTesting\API\UnitTestingIncrementalAnalyzerProvider.cs (2)

31var solutionCrawlerService = _workspace.Services.GetService<ISolutionCrawlerService>(); 41var solutionCrawlerRegistrationService = workspace.Services.GetService<ISolutionCrawlerRegistrationService>();

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingSolutionCrawlerService.cs (1)

43if (workspace.Services.GetService<IUnitTestingSolutionCrawlerRegistrationService>() is UnitTestingSolutionCrawlerRegistrationService registration)

ExternalAccess\VSTypeScript\Api\VSTypeScriptCompletionServiceWithProviders.cs (1)

19: base(workspace.Services.SolutionServices, AsynchronousOperationListenerProvider.NullProvider)

ExternalAccess\VSTypeScript\Api\VSTypeScriptDocumentNavigationServiceWrapper.cs (2)

27=> new(workspace.Services.GetRequiredService<IDocumentNavigationService>(), 28workspace.Services.GetRequiredService<IWorkspaceThreadingServiceProvider>());

FindUsages\DefinitionItem.DefaultDefinitionItem.cs (1)

52var navigationService = workspace.Services.GetRequiredService<ISymbolNavigationService>();

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (1)

118var service = workspace.Services.GetService<ILegacyGlobalOptionsWorkspaceService>();

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (3)

251var threadingService = workspace.Services.GetRequiredService<IWorkspaceThreadingServiceProvider>().Service; 278var (projectInfo, documentId) = fileInfo.GetProjectInfoAndDocumentId(workspace.Services.SolutionServices, loadFileFromDisk: true); 311workspace.OnDocumentClosed(documentId, new WorkspaceFileTextLoader(workspace.Services.SolutionServices, fileInfo.TemporaryFilePath, MetadataAsSourceGeneratedFileInfo.Encoding));

MetadataAsSource\MetadataAsSourceFileService.cs (2)

96_workspace ??= new MetadataAsSourceWorkspace(this, sourceWorkspace.Services.HostServices); 122var threadingService = workspace.Services.GetRequiredService<IWorkspaceThreadingServiceProvider>().Service;

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (3)

288var languageServices = workspace.Services.GetLanguageServices(languageName); 354var threadingService = workspace.Services.GetRequiredService<IWorkspaceThreadingServiceProvider>().Service; 383workspace.OnDocumentClosed(info.DocumentId, new WorkspaceFileTextLoader(workspace.Services.SolutionServices, filePath, info.Encoding));

SolutionCrawler\SolutionCrawlerService.cs (2)

36if (workspace.Services.GetService<ISolutionCrawlerRegistrationService>() is SolutionCrawlerRegistrationService registration) 45if (workspace.Services.GetService<ISolutionCrawlerRegistrationService>() is SolutionCrawlerRegistrationService registration)

SolutionCrawler\WorkCoordinator.cs (2)

49_documentTrackingService = _registration.Workspace.Services.GetRequiredService<IDocumentTrackingService>(); 50_solutionCrawlerOptions = _registration.Workspace.Services.GetService<ISolutionCrawlerOptionsService>();

SolutionCrawler\WorkCoordinator.IncrementalAnalyzerProcessor.cs (2)

79_documentTracker = _registration.Workspace.Services.GetRequiredService<IDocumentTrackingService>(); 81var globalNotificationService = _registration.Workspace.Services.SolutionServices.ExportProvider

Workspace\BackgroundCompiler.cs (1)

35var listenerProvider = workspace.Services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>();

Workspace\BackgroundParser.cs (2)

42var listenerProvider = workspace.Services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>(); 45_documentTrackingService = workspace.Services.GetRequiredService<IDocumentTrackingService>();

Features\Diagnostics\DiagnosticAnalyzerService.cs (1)

64var service = workspace.Services.GetService<ISolutionCrawlerService>();

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.cs (2)

59_documentTrackingService = workspace.Services.GetRequiredService<IDocumentTrackingService>(); 81var service = Workspace.Services.GetService<ISolutionCrawlerService>();

Handler\References\FindUsagesLSPContext.cs (1)

198var service = _workspace.Services.GetRequiredService<ILspReferencesResultCreationService>();

Workspaces\LspMiscellaneousFilesWorkspace.cs (1)

67this, uri.AbsolutePath, sourceTextLoader, languageInformation, documentText.ChecksumAlgorithm, Services.SolutionServices, ImmutableArray<MetadataReference>.Empty);

Completion\CompletionResolveTests.cs (1)

186document, new TestCaretOutOfScopeCompletionService(testLspServer.TestWorkspace.Services.SolutionServices), selectedItem, snippetsSupported: true, CancellationToken.None).ConfigureAwait(false);

VSTypeScriptHandlerTests.cs (1)

113workspace.Services.HostServices,

CompilerInvocation.cs (1)

38var languageServices = workspace.Services.GetLanguageServices(languageName).LanguageServices;

ExternalAccess\UnitTesting\Api\UnitTestingBrokeredServiceImplementation.cs (1)

27return NewUnitTestingIncrementalAnalyzerProvider.TryRegister(workspace.Kind, workspace.Services.SolutionServices, analyzerName, provider);

Host\RemoteWorkspace.cs (3)

45Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Unregister(this); 50var serializerService = Services.GetRequiredService<ISerializerService>(); 249var updater = new SolutionCreator(Services.HostServices, assetProvider, this.CurrentSolution);

Services\AssetSynchronization\RemoteAssetSynchronizationService.cs (1)

54var serializer = workspace.Services.GetRequiredService<ISerializerService>();

Services\AsynchronousOperationListener\RemoteAsynchronousOperationListenerService.cs (2)

41var exportProvider = workspace.Services.SolutionServices.ExportProvider; 53var exportProvider = workspace.Services.SolutionServices.ExportProvider;

Services\BrokeredServiceBase.cs (1)

80=> GetWorkspace().Services.SolutionServices;

Services\DiagnosticAnalyzer\RemoteDiagnosticAnalyzerService.cs (3)

45workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>().Register(workspace); 75var hostWorkspaceServices = this.GetWorkspace().Services; 106var service = GetWorkspace().Services.GetService<IPerformanceTrackerService>();

Services\EditAndContinue\RemoteEditAndContinueService.cs (1)

77=> GetWorkspace().Services.GetRequiredService<IEditAndContinueWorkspaceService>();

Services\GlobalNotificationDelivery\RemoteGlobalNotificationDeliveryService.cs (1)

55=> (RemoteGlobalOperationNotificationService)GetWorkspace().Services.SolutionServices.ExportProvider.GetExports<IGlobalOperationNotificationService>().Single().Value;

Services\ProcessTelemetry\RemoteProcessTelemetryService.cs (1)

53var services = GetWorkspace().Services;

Formatting\Indentation\SmartIndenterTests.vb (1)

2988Dim factory = CType(workspace.Services.GetService(Of IHostDependentFormattingRuleFactoryService)(),

Formatting\VisualBasicFormatterTestBase.vb (2)

54Dim formattingRuleProvider = workspace.Services.GetService(Of IHostDependentFormattingRuleFactoryService)() 67workspace.Services.SolutionServices,

LineSeparators\LineSeparatorTests.vb (1)

293Dim service = Assert.IsType(Of VisualBasicLineSeparatorService)(workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetService(Of ILineSeparatorService)())

MoveStaticMembers\VisualBasicMoveStaticMembersTests.vb (1)

3071Dim optionsService = DirectCast(workspace.Services.GetRequiredService(Of IMoveStaticMembersOptionsService)(), TestMoveStaticMembersService)

QuickInfo\SemanticQuickInfoSourceTests.vb (1)

23Dim service = workspace.Services _

Formatting\FormattingTests.vb (4)

3021Dim result = Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None) 3028Dim result2 = Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None) 3788Dim result = Formatter.Format(root, goo, workspace.Services.SolutionServices, VisualBasicSyntaxFormattingOptions.Default, CancellationToken.None).ToString() 4605Dim formatted = Formatter.Format(tree, workspace.Services.SolutionServices, options, CancellationToken.None)

Formatting\VisualBasicFormattingTestBase.vb (4)

67Dim changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), workspace.Services.SolutionServices, options, CancellationToken.None) 70changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), (Await syntaxTree.GetRootAsync()).FullSpan, workspace.Services.SolutionServices, options, CancellationToken.None) 76changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), spans, workspace.Services.SolutionServices, options, CancellationToken.None) 80AssertFormatWithTransformation(workspace.Services.SolutionServices, expected, syntaxTree.GetRoot(), spans, options, False)

Classification\Classifier.cs (1)

50return GetClassifiedSpans(workspace.Services.SolutionServices, project: null, semanticModel, textSpan, ClassificationOptions.Default, cancellationToken);

Diagnostics\DiagnosticProvider.cs (2)

20var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>(); 26var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>();

Editing\SyntaxEditor.cs (1)

66: this(root, (workspace ?? throw new ArgumentNullException(nameof(workspace))).Services.SolutionServices)

Editing\SyntaxGenerator.cs (1)

53=> GetGenerator(workspace.Services.SolutionServices, language);

FindSymbols\SymbolFinder.cs (1)

51return FindSymbolAtPositionAsync(semanticModel, position, workspace.Services.SolutionServices, cancellationToken);

Formatting\Formatter.cs (2)

243var languageServices = workspace.Services.GetLanguageServices(node.Language); 321var syntaxFormattingService = workspace.Services.GetRequiredLanguageService<ISyntaxFormattingService>(language);

ProjectExtensions.cs (1)

37=> project.Solution.Workspace.Services.GetExtendedLanguageServices(project.Language);

Remote\RemoteHostClient.cs (1)

47=> TryGetClientAsync(workspace.Services.SolutionServices, cancellationToken);

Shared\TestHooks\AsynchronousOperationListenerProvider.cs (1)

121if (workspace?.Services.GetService<IRemoteHostClientProvider>() is { } remoteHostClientProvider)

Simplification\Simplifier.cs (2)

86return Expand(node, semanticModel, workspace.Services.SolutionServices, expandInsideNode, expandParameter, cancellationToken); 131return Expand(token, semanticModel, workspace.Services.SolutionServices, expandInsideNode, cancellationToken);

Workspace\CommandLineProject.cs (1)

31var languageServices = tmpWorkspace.Services.SolutionServices.GetLanguageServices(language);

Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (2)

95var textLoader = new WorkspaceFileTextLoader(_project._projectSystemProjectFactory.Workspace.Services.SolutionServices, fullPath, defaultEncoding: null); 408documentsToChange.Add((documentId, new WorkspaceFileTextLoader(_project._projectSystemProjectFactory.Workspace.Services.SolutionServices, filePath, defaultEncoding: null)));

Workspace\ProjectSystem\ProjectSystemProject.cs (2)

236var telemetryService = _projectSystemProjectFactory.Workspace.Services.GetService<IWorkspaceTelemetryService>(); 240var workspaceStatusService = _projectSystemProjectFactory.Workspace.Services.GetService<IWorkspaceStatusService>();

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (2)

69WorkspaceListener = workspace.Services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>().GetListener(); 72FileWatchedReferenceFactory = new FileWatchedPortableExecutableReferenceFactory(workspace.Services.SolutionServices, fileChangeWatcher);

Workspace\Solution\Solution.cs (2)

42: this(new SolutionState(workspace.Kind, workspace.PartialSemanticsEnabled, workspace.Services.SolutionServices, solutionAttributes, options, analyzerReferences)) 54/// cref="Workspace.Services"/> when possible.

Workspace\Workspace.cs (2)

521this.Services.GetService<IWorkspaceEventListenerService>()?.Stop(); 529if (Services.GetService<IRemoteHostClientProvider>() is IDisposable disposableService)

Workspace\Workspace_Events.cs (1)

255this.Services.GetService<IWorkspaceEventListenerService>()?.EnsureListeners();

MSBuild\MSBuildProjectLoader.cs (1)

59: this(workspace.Services.SolutionServices, new DiagnosticReporter(workspace), projectFileLoaderRegistry: null, properties)

MSBuild\MSBuildWorkspace.cs (3)

44_projectFileLoaderRegistry = new ProjectFileLoaderRegistry(Services.SolutionServices, _reporter); 45_loader = new MSBuildProjectLoader(Services.SolutionServices, _reporter, _projectFileLoaderRegistry, properties); 455.WithTextLoader(new WorkspaceFileTextLoader(Services.SolutionServices, fullPath, text.Encoding));

VisualStudioMSBuildWorkspaceTests.cs (7)

43Assert.NotNull(workspace.Services); 44Assert.NotNull(workspace.Services.Workspace); 45Assert.Equal(workspace, workspace.Services.Workspace); 46Assert.NotNull(workspace.Services.HostServices); 47Assert.NotNull(workspace.Services.TextFactory); 3049var loader = workspace.Services 3062var commandLineParser = workspace.Services

Formatting\FormattingTestBase.cs (2)

63await AssertFormatAsync(workspace.Services.SolutionServices, expected, root, spans.AsImmutable(), formattingOptions, await document.GetTextAsync()); 66AssertFormatWithTransformation(workspace.Services.SolutionServices, expected, root, spans, formattingOptions, treeCompare, parseOptions);

Editing\SyntaxEditorTests.cs (2)

34var formatted = Formatter.Format(node, EmptyWorkspace.Services.SolutionServices, options, CancellationToken.None); 40=> new SyntaxEditor(root, EmptyWorkspace.Services.SolutionServices);

FindAllDeclarationsTests.TestSolutionsAndProject.cs (1)

84var remoteHostProvider = (InProcRemoteHostClientProvider)workspace.Services.GetRequiredService<IRemoteHostClientProvider>();

FormattingTests.cs (3)

38var service = workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService<ISyntaxFormattingService>(); 65var service = workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetService<ISyntaxFormattingService>(); 87var formattedRoot = Formatter.Format(tree.GetRoot(), workspace.Services.SolutionServices, options, CancellationToken.None);

Remote\ServiceDescriptorTests.cs (1)

234var languageServices = workspace.Services.SolutionServices.GetLanguageServices(language);

SolutionTests\SolutionTests.cs (8)

2653.AddDocument(did, "x", new WorkspaceFileTextLoader(workspace.Services.SolutionServices, file.Path, Encoding.UTF8)); 2665Assert.IsType<TemporaryStorageService>(workspace.Services.GetService<ITemporaryStorageServiceInternal>()); 2672Assert.IsType<TrivialTemporaryStorageService>(workspace.Services.GetService<ITemporaryStorageServiceInternal>()); 2712.AddDocument(did, "x", new WorkspaceFileTextLoader(workspace.Services.SolutionServices, file.Path, Encoding.UTF8)); 2779.AddDocument(did, "x", new WorkspaceFileTextLoader(workspace.Services.SolutionServices, file.Path, Encoding.UTF8)); 3204var service = ws.Services.GetLanguageServices(LanguageNames.CSharp).GetService<ITestLanguageService>(); 3208var service2 = ws2.Services.GetLanguageServices(LanguageNames.CSharp).GetService<ITestLanguageService>(); 4258var optionService = workspace.Services.GetRequiredService<ILegacyWorkspaceOptionService>().LegacyGlobalOptions;

UtilityTest\SourceTextSerializationTests.cs (1)

25var textService = Assert.IsType<TextFactoryService>(workspace.Services.GetService<ITextFactoryService>());

WorkspaceServiceTests\GlobalOptionServiceTests.cs (13)

WorkspaceServiceTests\TemporaryStorageServiceTests.cs (22)

WorkspaceTests\AdhocWorkspaceTests.cs (2)

420: base(solution.Workspace.Services.HostServices, solution.Workspace.Kind) 598var service = ws.Services.GetService<IDocumentTextDifferencingService>();

InProcess\VisualStudioWorkspace_InProc.cs (1)

115var hook = _visualStudioWorkspace.Services.GetRequiredService<IWorkpacePartialSolutionsTestHook>();

CallHierarchy\CallHierarchyDetail.cs (1)

82var navigator = _workspace.Services.GetService<IDocumentNavigationService>();

CodeCleanup\AbstractCodeCleanUpFixer.cs (2)

83var hierarchyToProjectMap = _workspace.Services.GetRequiredService<IHierarchyItemToProjectIdMap>(); 221var workspaceStatusService = workspace.Services.GetService<IWorkspaceStatusService>();

CodeLens\CodeLensCallbackListener.cs (4)

61var service = _workspace.Services.GetRequiredService<ICodeLensReferencesService>(); 89var service = _workspace.Services.GetRequiredService<ICodeLensReferencesService>(); 115var service = _workspace.Services.GetRequiredService<ICodeLensReferencesService>(); 137var service = _workspace.Services.GetRequiredService<ICodeLensReferencesService>();

DebuggerIntelliSense\DebuggerIntellisenseWorkspace.cs (1)

15: base(solution.Workspace.Services.HostServices, WorkspaceKind.Debugger)

DesignerAttribute\VisualStudioDesignerAttributeService.cs (2)

109var statusService = _workspace.Services.GetRequiredService<IWorkspaceStatusService>(); 125var trackingService = _workspace.Services.GetRequiredService<IDocumentTrackingService>();

Diagnostics\DiagnosticProgressReporter.cs (1)

101var crawlerService = _workspace.Services.GetRequiredService<ISolutionCrawlerService>();

Diagnostics\VisualStudioDiagnosticAnalyzerProvider.WorkspaceEventListener.cs (1)

46var setter = workspace.Services.GetService<ISolutionAnalyzerSetterWorkspaceService>();

Diagnostics\VisualStudioDiagnosticAnalyzerService.cs (1)

414var projectMap = _workspace.Services.GetRequiredService<IHierarchyItemToProjectIdMap>();

EditorConfigSettings\SettingsEditorFactory.cs (1)

48_settingsDataProviderFactory = workspace.Services.GetRequiredService<ISettingsAggregator>();

ExternalAccess\LegacyCodeAnalysis\LegacyCodeAnalysisVisualStudioSuppressionFixServiceAccessor.cs (3)

38var errorReportingService = _workspace.Services.GetRequiredService<IErrorReportingService>(); 60var errorReportingService = _workspace.Services.GetRequiredService<IErrorReportingService>(); 82var errorReportingService = _workspace.Services.GetRequiredService<IErrorReportingService>();

FindReferences\Entries\DocumentSpanEntry.cs (2)

291var documentNavigationService = workspace.Services.GetService<IDocumentNavigationService>(); 308var documentNavigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();

Implementation\AbstractEditorFactory.cs (1)

353var formattedRoot = Formatter.Format(rootToFormat, workspace.Services.SolutionServices, cleanupOptions.FormattingOptions, cancellationToken);

Implementation\VirtualMemoryNotificationListener.cs (2)

50_workspaceCacheService = workspace.Services.GetService<IWorkspaceCacheService>() as WorkspaceCacheService; 162_workspace.Services.GetRequiredService<IErrorReportingService>()

InlineRename\InlineRenameUndoManager.cs (1)

111var textUndoHistoryService = workspace.Services.GetService<ITextUndoHistoryWorkspaceService>();

LanguageService\AbstractCreateServicesOnTextViewConnection.cs (1)

107var languageServices = Workspace.Services.GetExtendedLanguageServices(_languageName);

LanguageService\AbstractLanguageService`2.cs (2)

169var formatter = this.Workspace.Services.GetLanguageServices(RoslynLanguageName).GetService<ISyntaxFormattingService>(); 266var languageServices = workspace.Services.GetLanguageServices(RoslynLanguageName);

LanguageService\AbstractLanguageService`2.IVsLanguageTextOps.cs (1)

68var ruleFactory = Workspace.Services.GetService<IHostDependentFormattingRuleFactoryService>();

LanguageService\AbstractPackage`2.cs (2)

95_packageInstallerService = workspace.Services.GetService<IPackageInstallerService>() as PackageInstallerService; 96_symbolSearchService = workspace.Services.GetService<ISymbolSearchService>() as VisualStudioSymbolSearchService;

Library\ObjectBrowser\AbstractObjectBrowserLibraryManager.cs (1)

58_libraryService = new Lazy<ILibraryService>(() => Workspace.Services.GetLanguageServices(_languageName).GetService<ILibraryService>());

NavigateTo\VisualStudioNavigateToItemProviderFactory.cs (1)

43if (_workspace.Services.GetRequiredService<IWorkspaceContextService>().IsInLspEditorContext())

Packaging\PackageInstallerServiceFactory.cs (2)

355var notificationService = Workspace.Services.GetService<INotificationService>(); 416var notificationService = Workspace.Services.GetService<INotificationService>();

Progression\GraphNavigatorExtension.cs (1)

98var navigationService = editorWorkspace.Services.GetService<IDocumentNavigationService>();

ProjectSystem\MiscellaneousFilesWorkspace.cs (4)

70: base(visualStudioWorkspace.Services.HostServices, WorkspaceKind.MiscellaneousFiles) 132var manager = this.Services.GetService<VisualStudioMetadataReferenceManager>(); 294var fileLoader = new WorkspaceFileTextLoader(Services.SolutionServices, filePath, defaultEncoding: null); 296this, filePath, fileLoader, languageInformation, checksumAlgorithm, Services.SolutionServices, _metadataReferences);

ProjectSystem\TextEditApplication.cs (1)

36var undoService = workspace.Services.GetRequiredService<ISourceTextUndoService>();

ProjectSystem\VisualStudioProjectFactory.cs (1)

71_visualStudioWorkspaceImpl.Services.GetRequiredService<VisualStudioMetadataReferenceManager>();

ProjectSystem\VisualStudioWorkspace.cs (4)

37_backgroundCompilationDisabled = this.Services.GetRequiredService<IWorkspaceConfigurationService>().Options.DisableBackgroundCompilation; 42var cacheService = Services.GetService<IWorkspaceCacheService>(); 63var cacheService = Services.GetService<IWorkspaceCacheService>(); 131=> this.Services.GetRequiredService<IMetadataService>().GetReference(filePath, properties);

ProjectSystem\VisualStudioWorkspaceImpl.cs (5)

146_workspaceListener = Services.GetRequiredService<IWorkspaceAsynchronousOperationListenerProvider>().GetListener(); 226var telemetryService = (VisualStudioWorkspaceTelemetryService)Services.GetRequiredService<IWorkspaceTelemetryService>(); 233var taskListService = this.Services.SolutionServices.ExportProvider.GetExports<VisualStudioTaskListService>().Single().Value; 724var documentTrackingService = this.Services.GetRequiredService<IDocumentTrackingService>(); 1523language => Services.GetLanguageServices(language).GetService<IProjectExistsUIContextProviderLanguageService>()?.GetUIContext());

ProjectSystem\VisualStudioWorkspaceImpl.OpenFileTracker.cs (3)

336w.OnDocumentClosed(documentId, new WorkspaceFileTextLoader(w.Services.SolutionServices, moniker, defaultEncoding: null)); 340w.OnAdditionalDocumentClosed(documentId, new WorkspaceFileTextLoader(w.Services.SolutionServices, moniker, defaultEncoding: null)); 345w.OnAnalyzerConfigDocumentClosed(documentId, new WorkspaceFileTextLoader(w.Services.SolutionServices, moniker, defaultEncoding: null));

Remote\VisualStudioWorkspaceServiceHubConnector.cs (2)

52_globalNotificationDelivery = new GlobalNotificationRemoteDeliveryService(workspace.Services.SolutionServices, _disposalCancellationSource.Token); 55var service = workspace.Services.GetRequiredService<IRemoteHostClientProvider>();

Snippets\AbstractSnippetExpansionClient.cs (2)

125_argumentProviders = workspace.Services.SolutionServices 1111var notificationService = workspace.Services.GetRequiredService<INotificationService>();

StackTraceExplorer\StackFrameViewModel.cs (2)

53_stackExplorerService = workspace.Services.GetRequiredService<IStackTraceExplorerService>(); 130var navigationService = _workspace.Services.GetService<IDocumentNavigationService>();

SymbolSearch\AbstractDelayStartedService.cs (1)

107var statusService = this.Workspace.Services.GetRequiredService<IWorkspaceStatusService>();

SymbolSearch\VisualStudioSymbolSearchService.cs (1)

72_installerService = workspace.Services.GetService<IPackageInstallerService>();

SyncNamespaces\SyncNamespacesCommandHandler.cs (1)

148var previewChangeService = _workspace.Services.GetRequiredService<IPreviewDialogService>();

TableDataSource\AbstractRoslynTableDataSource.cs (1)

44var crawlerService = workspace.Services.GetService<ISolutionCrawlerService>();

TableDataSource\AbstractTableEntriesSnapshot.cs (1)

168var navigationService = workspace.Services.GetService<IDocumentNavigationService>();

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (2)

87_fixMultipleOccurencesService = workspace.Services.GetRequiredService<IFixMultipleOccurrencesService>(); 88_projectMap = workspace.Services.GetRequiredService<IHierarchyItemToProjectIdMap>();

TaskList\ExternalErrorDiagnosticUpdateSource.cs (2)

106_buildOnlyDiagnosticsService = _workspace.Services.GetRequiredService<IBuildOnlyDiagnosticsService>(); 322var registrationService = (SolutionCrawlerRegistrationService)_workspace.Services.GetRequiredService<ISolutionCrawlerRegistrationService>();

TaskList\VisualStudioTaskListService.cs (2)

91var workspaceStatus = workspace.Services.GetRequiredService<IWorkspaceStatusService>(); 163var services = _workspace.Services.SolutionServices;

UnusedReferences\RemoveUnusedReferencesCommandHandler.cs (1)

43=> _workspace.Services.GetRequiredService<IReferenceCleanupService>();

ValueTracking\ValueTrackedTreeItemViewModel.cs (1)

179var navigationService = Workspace.Services.GetService<IDocumentNavigationService>();

Venus\ContainedDocument.cs (3)

607_workspace.Services.GetLanguageServices(_project.Language).GetService<IContentTypeLanguageService>().GetDefaultContentType()); 977var service = _workspace.Services.GetLanguageServices(_project.Language).GetService<IVenusBraceMatchingService>(); 1001var syntaxFact = _workspace.Services.GetLanguageServices(_project.Language).GetService<ISyntaxFactsService>();

Workspace\SourceGeneratedFileManager.cs (1)

256_workspaceConfigurationService = _workspace.Services.GetService<IWorkspaceConfigurationService>();

Workspace\VisualStudioSymbolNavigationService.cs (1)

173var navigationService = editorWorkspace.Services.GetRequiredService<IDocumentNavigationService>();

CSharpPackage.cs (1)

76return new TempPECompilerService(workspace.Services.GetService<IMetadataService>());

Interactive\CSharpVsInteractiveWindowProvider.cs (1)

76workspace.Services.HostServices,

Options\NamingStylesOptionPage.cs (1)

28_notificationService = workspace.Services.GetService<INotificationService>();

ProjectSystemShim\CSharpProjectShim.cs (1)

70this.ProjectSystemProjectOptionsProcessor = new OptionsProcessor(this.ProjectSystemProject, Workspace.Services.SolutionServices);

EditorConfigSettings\Aggregator\SettingsAggregatorTests.cs (1)

41var settingsAggregator = workspace.Services.GetRequiredService<ISettingsAggregator>();

EditorConfigSettings\DataProvider\DataProviderTests.cs (4)

39=> GetWorkspace("/a/b/proj1.csproj").Services.GetRequiredService<IWorkspaceSettingsProviderFactory<T>>(); 42=> GetWorkspace("/a/b/proj1.csproj").Services.GetLanguageServices(languageName).GetRequiredService<ILanguageSettingsProviderFactory<T>>(); 45=> GetWorkspace().Services.GetRequiredService<IWorkspaceSettingsProviderFactory<T>>(); 48=> GetWorkspace().Services.GetLanguageServices(languageName).GetRequiredService<ILanguageSettingsProviderFactory<T>>();

F1Help\F1HelpTests.cs (1)

31var service = Assert.IsType<CSharpHelpContextService>(workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService<IHelpContextService>());

PersistentStorage\AbstractPersistentStorageTests.cs (18)

Options\AbstractOptionPreviewViewModel.cs (1)

129var metadataService = workspace.Services.GetService<IMetadataService>();

ProjectSystem\CPS\CPSProject_IWorkspaceProjectContext.cs (2)

89if (visualStudioWorkspace.Services.GetLanguageServices(projectSystemProject.Language).GetService<ICommandLineParserService>() != null) 91_projectSystemProjectOptionsProcessor = new ProjectSystemProjectOptionsProcessor(_projectSystemProject, visualStudioWorkspace.Services.SolutionServices);

RoslynVisualStudioWorkspace.cs (1)

59var globalUndoService = this.Services.GetRequiredService<IGlobalUndoService>();

SolutionExplorer\AnalyzersCommandHandler.cs (1)

653var notificationService = workspace.Services.GetService<INotificationService>();

SolutionExplorer\AnalyzersFolderItem\AnalyzersFolderItemSourceProvider.cs (1)

81_projectMap ??= _workspace.Services.GetService<IHierarchyItemToProjectIdMap>();

SolutionExplorer\DiagnosticItem\CpsDiagnosticItemSourceProvider.cs (1)

149_projectMap ??= _workspace.Services.GetService<IHierarchyItemToProjectIdMap>();

SolutionExplorer\SourceGeneratedFileItems\SourceGeneratedFileItem.cs (1)

73var documentNavigationService = item.Workspace.Services.GetService<IDocumentNavigationService>();

Client\Projects\RoslynRemoteProjectInfoProvider.cs (1)

80var projectInfo = CreateProjectInfo(project.Name, project.Language, files.Select(f => f.LocalPath).ToImmutableArray(), _remoteLanguageServiceWorkspace.Services.SolutionServices);

Client\RemoteLanguageServiceWorkspace.cs (2)

353loader: new WorkspaceFileTextLoader(Services.SolutionServices, filePath, defaultEncoding: null), 388OnDocumentClosed(id, new WorkspaceFileTextLoaderNoException(Services.SolutionServices, moniker, defaultEncoding: null));

CallHierarchy\CallHierarchyTestState.vb (1)

94Dim notificationService = DirectCast(workspace.Services.GetService(Of INotificationService)(), INotificationServiceCallback)

CodeModel\Mocks\MockVisualStudioWorkspace.vb (1)

41Me.Services.GetService(Of IWorkspaceEventListenerService)()

CallHierarchy\CallHierarchyTests.vb (2)

323Dim mockNavigationService = DirectCast(testState.Workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationServiceProvider.MockDocumentNavigationService) 364Dim navigationService = DirectCast(testState.Workspace.Services.GetService(Of IDocumentNavigationService)(), MockDocumentNavigationServiceProvider.MockDocumentNavigationService)

Completion\CSharpCompletionSnippetNoteTests.vb (2)

119Dim testSnippetInfoService = DirectCast(state.Workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService(Of ISnippetInfoService)(), TestCSharpSnippetInfoService) 137Dim testSnippetInfoService = DirectCast(state.Workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService(Of ISnippetInfoService)(), TestCSharpSnippetInfoService)

Completion\VisualBasicCompletionSnippetNoteTests.vb (1)

87Dim testSnippetInfoService = DirectCast(state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetService(Of ISnippetInfoService)(), TestVisualBasicSnippetInfoService)

Diagnostics\DiagnosticTableDataSourceTests.vb (1)

759Dim service = DirectCast(workspace.Services.GetService(Of ISolutionCrawlerRegistrationService)(), SolutionCrawlerRegistrationService)

Diagnostics\ExternalDiagnosticUpdateSourceTests.vb (3)

145Dim buildOnlyDiagnosticService = workspace.Services.GetRequiredService(Of IBuildOnlyDiagnosticsService) 310Dim buildOnlyDiagnosticService = workspace.Services.GetRequiredService(Of IBuildOnlyDiagnosticsService) 558Dim buildOnlyDiagnosticService = workspace.Services.GetRequiredService(Of IBuildOnlyDiagnosticsService)

Options\NamingStylesOptionPage.vb (1)

24_notificationService = workspace.Services.GetService(Of INotificationService)

ProjectSystemShim\TempPECompiler.vb (1)

28Dim metadataService = _workspace.Services.GetService(Of IMetadataService)

ProjectSystemShim\VisualBasicProject.vb (1)

52VisualStudioProjectOptionsProcessor = New OptionsProcessor(ProjectSystemProject, Workspace.Services.SolutionServices)

OptionPages\PerformanceLoggersPage.cs (1)

43_workspaceServices = workspace.Services.SolutionServices;

VisualStudioDiagnosticsWindowPackage.cs (1)

96PerformanceLoggersPage.SetLoggers(globalOptions, _threadingContext, _workspace.Services.SolutionServices);

Remote\RemoteHostClientServiceFactoryTests.cs (3)

40var exportProvider = workspace.Services.SolutionServices.ExportProvider; 45var service = workspace.Services.GetRequiredService<IRemoteHostClientProvider>(); 79var service = workspace.Services.GetRequiredService<IRemoteHostClientProvider>();

Remote\SnapshotSerializationTests.cs (26)

Services\AssetProviderTests.cs (8)

Services\ServiceHubServicesTests.cs (2)

110var assetSource = new SimpleAssetSource(workspace.Services.GetService<ISerializerService>(), map); 112return new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService<ISerializerService>());

Services\SolutionServiceTests.cs (15)

Services\VisualStudioDiagnosticAnalyzerExecutorTests.cs (6)

60IdeAnalyzerOptions.GetDefault(workspace.Services.SolutionServices.GetLanguageServices(LanguageNames.CSharp))); 101var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(workspace.Services.SolutionServices.GetLanguageServices(LanguageNames.VisualBasic)); 137var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(workspace.Services.SolutionServices.GetLanguageServices(LanguageNames.CSharp)); 183var ideAnalyzerOptions = IdeAnalyzerOptions.GetDefault(workspace.Services.SolutionServices.GetLanguageServices(LanguageNames.CSharp)); 223var remotableDataService = workspace.Services.GetService<ISolutionAssetStorageProvider>(); 224var serializer = workspace.Services.GetRequiredService<ISerializerService>();