Use Create and GetOrCreate method prefixes as appropriate for clarity

src/EditorFeatures/CSharpTest/ChangeSignature/RemoveParametersTests.cs

@@ -272,7 +272,7 @@ void M()
         public void ChangeSignatureCommandDisabledInSubmission()
         {
             var exportProvider = ExportProviderCache
-                .CreateExportProviderFactory(
+                .GetOrCreateExportProviderFactory(
                     TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
                 .CreateExportProvider();
 

src/EditorFeatures/CSharpTest/EncapsulateField/EncapsulateFieldCommandHandlerTests.cs

@@ -193,7 +193,7 @@ static void Main(string[] args)
         public void EncapsulateFieldCommandDisabledInSubmission()
         {
             var exportProvider = ExportProviderCache
-                .CreateExportProviderFactory(
+                .GetOrCreateExportProviderFactory(
                     TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
                 .CreateExportProvider();
 

src/EditorFeatures/CSharpTest/EncapsulateField/EncapsulateFieldTestState.cs

@@ -28,7 +28,7 @@ internal class EncapsulateFieldTestState : IDisposable
         public string NotificationMessage { get; private set; }
 
         private static readonly IExportProviderFactory s_exportProviderFactory =
-            ExportProviderCache.CreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithParts(
                     typeof(CSharpEncapsulateFieldService),
                     typeof(EditorNotificationServiceFactory),

src/EditorFeatures/CSharpTest/ExtractInterface/ExtractInterfaceTests.cs

@@ -1061,7 +1061,7 @@ class $$Test<T, U>
         public void ExtractInterfaceCommandDisabledInSubmission()
         {
             var exportProvider = ExportProviderCache
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
                 .CreateExportProvider();
 
             using (var workspace = TestWorkspace.Create(XElement.Parse(@"

src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs

@@ -10353,7 +10353,7 @@ public async Task ExtractMethod_Argument2()
         public void ExtractMethodCommandDisabledInSubmission()
         {
             var exportProvider = ExportProviderCache
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
                 .CreateExportProvider();
 
             using (var workspace = TestWorkspace.Create(XElement.Parse(@"

src/EditorFeatures/CSharpTest/Organizing/OrganizeTypeDeclarationTests.cs

@@ -1077,7 +1077,7 @@ void B()
         public void OrganizingCommandsDisabledInSubmission()
         {
             var exportProvider = ExportProviderCache
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService)))
                 .CreateExportProvider();
 
             using (var workspace = TestWorkspace.Create(XElement.Parse(@"

src/EditorFeatures/Test/Utilities/EditorServicesUtil.cs

@@ -19,7 +19,7 @@ private static IExportProviderFactory CreateExportProviderFactory()
             var assemblies = TestExportProvider
                 .GetCSharpAndVisualBasicAssemblies()
                 .Concat(new[] { typeof(EditorServicesUtil).Assembly });
-            return ExportProviderCache.CreateExportProviderFactory(ExportProviderCache.CreateAssemblyCatalog(assemblies, ExportProviderCache.CreateResolver()));
+            return ExportProviderCache.GetOrCreateExportProviderFactory(ExportProviderCache.GetOrCreateAssemblyCatalog(assemblies, ExportProviderCache.CreateResolver()));
         }
     }
 }

src/EditorFeatures/Test2/Classification/ClassificationTests.vb

@@ -30,7 +30,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Classification
             </Workspace>
 
             Dim exportProvider = ExportProviderCache _
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic().WithParts(GetType(NoCompilationEditorClassificationService))) _
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic().WithParts(GetType(NoCompilationEditorClassificationService))) _
                 .CreateExportProvider()
 
             Using workspace = TestWorkspace.Create(workspaceDefinition, exportProvider:=exportProvider)

src/EditorFeatures/Test2/GoToDefinition/GoToDefinitionCommandHandlerTests.vb

@@ -56,7 +56,7 @@ class C
 
             Using workspace = TestWorkspace.Create(
                     definition,
-                    exportProvider:=ExportProviderCache.CreateExportProviderFactory(GoToTestHelpers.Catalog.WithPart(GetType(CSharpGoToDefinitionService))).CreateExportProvider())
+                    exportProvider:=ExportProviderCache.GetOrCreateExportProviderFactory(GoToTestHelpers.Catalog.WithPart(GetType(CSharpGoToDefinitionService))).CreateExportProvider())
 
                 Dim baseDocument = workspace.Documents.First(Function(d) Not d.IsLinkFile)
                 Dim linkDocument = workspace.Documents.First(Function(d) d.IsLinkFile)

src/EditorFeatures/Test2/NavigableSymbols/NavigableSymbolsTest.vb

@@ -20,7 +20,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.NavigableSymbols
     Public Class NavigableSymbolsTest
 
         Private Shared ReadOnly s_exportProviderFactory As IExportProviderFactory =
-            ExportProviderCache.CreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(
                     GetType(MockDocumentNavigationServiceProvider),
                     GetType(MockSymbolNavigationServiceProvider)))

src/EditorFeatures/Test2/Rename/RenameCommandHandlerTests.vb

@@ -51,7 +51,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Rename
         <Trait(Traits.Feature, Traits.Features.Interactive)>
         Public Sub RenameCommandDisabledInSubmission()
             Dim exportProvider = ExportProviderCache _
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
                 .CreateExportProvider()
 
             Using workspace = TestWorkspace.Create(

src/EditorFeatures/Test2/Rename/RenameTestHelpers.vb

@@ -21,7 +21,7 @@ Imports Roslyn.Utilities
 Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Rename
     Friend Module RenameTestHelpers
 
-        Friend _exportProviderFactory As IExportProviderFactory = ExportProviderCache.CreateExportProviderFactory(
+        Friend _exportProviderFactory As IExportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
             TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(MockDocumentNavigationServiceFactory)))
 
         Friend ReadOnly Property ExportProviderFactory As IExportProviderFactory

src/EditorFeatures/TestUtilities/AbstractCommandHandlerTestState.cs

@@ -143,7 +143,7 @@ private static ExportProvider GetExportProvider(bool useMinimumCatalog, Composab
                 ? TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic
                 : TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic;
 
-            return ExportProviderCache.CreateExportProviderFactory(baseCatalog.WithParts(extraParts)).CreateExportProvider();
+            return ExportProviderCache.GetOrCreateExportProviderFactory(baseCatalog.WithParts(extraParts)).CreateExportProvider();
         }
 
         public virtual ITextView TextView

src/EditorFeatures/TestUtilities/ChangeSignature/ChangeSignatureTestState.cs

@@ -80,7 +80,7 @@ public ChangeSignatureResult ChangeSignature()
         }
 
         private static readonly IExportProviderFactory s_exportProviderFactory =
-            ExportProviderCache.CreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic
                     .WithPart(typeof(TestChangeSignatureOptionsService))
                     .WithPart(typeof(CSharpChangeSignatureService))

src/EditorFeatures/TestUtilities/Diagnostics/GenerateType/GenerateTypeTestState.cs

@@ -105,7 +105,7 @@ public TestProjectManagementService TestProjectManagementService
         }
 
         private static readonly IExportProviderFactory s_exportProviderFactory =
-            ExportProviderCache.CreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithParts(
                     typeof(TestGenerateTypeOptionsService),
                     typeof(TestProjectManagementService),

src/EditorFeatures/TestUtilities/ExtractInterface/ExtractInterfaceTestState.cs

@@ -52,7 +52,7 @@ public ExtractInterfaceTestState(TestWorkspace workspace)
         }
 
         public static readonly IExportProviderFactory ExportProviderFactory =
-            ExportProviderCache.CreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic
                     .WithPart(typeof(TestExtractInterfaceOptionsService))
                     .WithPart(typeof(CSharpExtractInterfaceService))

src/EditorFeatures/TestUtilities/ServiceTestExportProvider.cs

@@ -20,7 +20,7 @@ public static class ServiceTestExportProvider
     {
         public static ComposableCatalog CreateAssemblyCatalog()
         {
-            return ExportProviderCache.CreateAssemblyCatalog(
+            return ExportProviderCache.GetOrCreateAssemblyCatalog(
                 GetLanguageNeutralTypes().Select(t => t.Assembly).Distinct().Concat(MinimalTestExportProvider.GetEditorAssemblies()), ExportProviderCache.CreateResolver());
         }
 

src/EditorFeatures/TestUtilities/TestExportProvider.cs

@@ -23,7 +23,7 @@ public static class TestExportProvider
             new Lazy<ComposableCatalog>(() => CreateAssemblyCatalogWithCSharpAndVisualBasic());
 
         private static Lazy<IExportProviderFactory> s_lazyExportProviderFactoryWithCSharpAndVisualBasic =
-            new Lazy<IExportProviderFactory>(() => ExportProviderCache.CreateExportProviderFactory(EntireAssemblyCatalogWithCSharpAndVisualBasic));
+            new Lazy<IExportProviderFactory>(() => ExportProviderCache.GetOrCreateExportProviderFactory(EntireAssemblyCatalogWithCSharpAndVisualBasic));
 
         public static ComposableCatalog EntireAssemblyCatalogWithCSharpAndVisualBasic
             => s_lazyEntireAssemblyCatalogWithCSharpAndVisualBasic.Value;
@@ -36,10 +36,10 @@ public static ExportProvider ExportProviderWithCSharpAndVisualBasic
 
         private static Lazy<ComposableCatalog> s_lazyMinimumCatalogWithCSharpAndVisualBasic =
             new Lazy<ComposableCatalog>(() => ExportProviderCache.CreateTypeCatalog(GetNeutralAndCSharpAndVisualBasicTypes())
-                        .WithParts(ExportProviderCache.CreateAssemblyCatalog(MinimalTestExportProvider.GetEditorAssemblies())));
+                        .WithParts(ExportProviderCache.GetOrCreateAssemblyCatalog(MinimalTestExportProvider.GetEditorAssemblies())));
 
         private static Lazy<IExportProviderFactory> s_lazyMinimumExportProviderFactoryWithCSharpAndVisualBasic =
-            new Lazy<IExportProviderFactory>(() => ExportProviderCache.CreateExportProviderFactory(MinimumCatalogWithCSharpAndVisualBasic));
+            new Lazy<IExportProviderFactory>(() => ExportProviderCache.GetOrCreateExportProviderFactory(MinimumCatalogWithCSharpAndVisualBasic));
 
         public static ComposableCatalog MinimumCatalogWithCSharpAndVisualBasic
             => s_lazyMinimumCatalogWithCSharpAndVisualBasic.Value;
@@ -116,13 +116,13 @@ private static Type[] GetNeutralAndCSharpAndVisualBasicTypes()
 
         private static IExportProviderFactory CreateExportProviderFactoryWithCSharpAndVisualBasic()
         {
-            return ExportProviderCache.CreateExportProviderFactory(EntireAssemblyCatalogWithCSharpAndVisualBasic);
+            return ExportProviderCache.GetOrCreateExportProviderFactory(EntireAssemblyCatalogWithCSharpAndVisualBasic);
         }
 
         private static ComposableCatalog CreateAssemblyCatalogWithCSharpAndVisualBasic()
         {
             return ExportProviderCache
-                .CreateAssemblyCatalog(GetCSharpAndVisualBasicAssemblies(), ExportProviderCache.CreateResolver())
+                .GetOrCreateAssemblyCatalog(GetCSharpAndVisualBasicAssemblies(), ExportProviderCache.CreateResolver())
                 .WithCompositionService();
         }
 

src/EditorFeatures/TestUtilities2/Utilities/GoToHelpers/GoToTestHelpers.vb

@@ -19,7 +19,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities.GoToHelpers
                         GetType(CSharpGeneratedCodeRecognitionService),
                         GetType(VisualBasicGeneratedCodeRecognitionService))
 
-        Public ReadOnly ExportProviderFactory As IExportProviderFactory = ExportProviderCache.CreateExportProviderFactory(Catalog)
+        Public ReadOnly ExportProviderFactory As IExportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(Catalog)
     End Module
 
     Friend Structure FilePathAndSpan

src/EditorFeatures/VisualBasicTest/ChangeSignature/RemoveParametersTests.vb

@@ -96,7 +96,7 @@ End Module
         <Trait(Traits.Feature, Traits.Features.Interactive)>
         Public Sub TestChangeSignatureCommandDisabledInSubmission()
             Dim exportProvider = ExportProviderCache _
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
                 .CreateExportProvider()
 
             Using workspace = TestWorkspace.Create(

src/EditorFeatures/VisualBasicTest/EncapsulateField/EncapsulateFieldCommandHandlerTests.vb

@@ -134,7 +134,7 @@ End Class
         <Trait(Traits.Feature, Traits.Features.Interactive)>
         Public Sub EncapsulateFieldCommandDisabledInSubmission()
             Dim exportProvider = ExportProviderCache _
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
                 .CreateExportProvider()
 
             Using workspace = TestWorkspace.Create(

src/EditorFeatures/VisualBasicTest/EncapsulateField/EncapsulateFieldTestState.vb

@@ -20,7 +20,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EncapsulateField
         Public TargetDocument As Document
 
         Private Shared ReadOnly s_exportProviderFactory As IExportProviderFactory =
-            ExportProviderCache.CreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithParts(
                     GetType(VisualBasicEncapsulateFieldService),
                     GetType(DefaultDocumentSupportsFeatureService)))

src/EditorFeatures/VisualBasicTest/ExtractInterface/ExtractInterfaceTests.vb

@@ -1262,7 +1262,7 @@ End Namespace
         <Trait(Traits.Feature, Traits.Features.Interactive)>
         Public Sub TestExtractInterfaceCommandDisabledInSubmission()
             Dim exportProvider = ExportProviderCache _
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
                 .CreateExportProvider()
 
             Using workspace = TestWorkspace.Create(

src/EditorFeatures/VisualBasicTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.vb

@@ -3367,7 +3367,7 @@ End Namespace"
             <Trait(Traits.Feature, Traits.Features.Interactive)>
             Public Sub TestExtractMethodCommandDisabledInSubmission()
                 Dim exportProvider = ExportProviderCache _
-                    .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
+                    .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
                     .CreateExportProvider()
 
                 Using workspace = TestWorkspace.Create(

src/EditorFeatures/VisualBasicTest/Organizing/OrganizeTypeDeclarationTests.vb

@@ -939,7 +939,7 @@ End Namespace</element>
         <Trait(Traits.Feature, Traits.Features.Interactive)>
         Public Sub TestOrganizingCommandsDisabledInSubmission()
             Dim exportProvider = ExportProviderCache _
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(GetType(InteractiveDocumentSupportsFeatureService))) _
                 .CreateExportProvider()
 
             Using workspace = TestWorkspace.Create(

src/VisualStudio/CSharp/Test/CodeModel/VisualStudioTestExportProvider.cs

@@ -13,9 +13,9 @@ public static class VisualStudioTestExportProvider
 
         static VisualStudioTestExportProvider()
         {
-            Factory = ExportProviderCache.CreateExportProviderFactory(
+            Factory = ExportProviderCache.GetOrCreateExportProviderFactory(
                 TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(
-                    ExportProviderCache.CreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly)));
+                    ExportProviderCache.GetOrCreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly)));
         }
     }
 }

src/VisualStudio/CSharp/Test/Interactive/InteractiveWindowTestHost.cs

@@ -21,8 +21,8 @@ public sealed class InteractiveWindowTestHost : IDisposable
 
         private readonly System.ComponentModel.Composition.Hosting.ExportProvider _exportProvider;
 
-        internal static readonly IExportProviderFactory ExportProviderFactory = ExportProviderCache.CreateExportProviderFactory(
-            ExportProviderCache.CreateAssemblyCatalog(
+        internal static readonly IExportProviderFactory ExportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
+            ExportProviderCache.GetOrCreateAssemblyCatalog(
                 new[]
                 {
                     typeof(TestWaitIndicator).Assembly,

src/VisualStudio/Core/Test.Next/Mocks/TestHostServices.cs

@@ -19,14 +19,14 @@ public static HostServices CreateHostServices(ExportProvider exportProvider = nu
         public static ExportProvider CreateMinimalExportProvider()
         {
             return ExportProviderCache
-                .CreateExportProviderFactory(ServiceTestExportProvider.CreateAssemblyCatalog().WithPart(typeof(InProcRemoteHostClientFactory)))
+                .GetOrCreateExportProviderFactory(ServiceTestExportProvider.CreateAssemblyCatalog().WithPart(typeof(InProcRemoteHostClientFactory)))
                 .CreateExportProvider();
         }
 
         public static ExportProvider CreateExportProvider()
         {
             return ExportProviderCache
-                .CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(InProcRemoteHostClientFactory)))
+                .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(InProcRemoteHostClientFactory)))
                 .CreateExportProvider();
         }
     }

src/VisualStudio/Core/Test/Preview/PreviewChangesTests.vb

@@ -14,7 +14,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Preview
     <[UseExportProvider]>
     Public Class PreviewChangesTests
 
-        Private _exportProviderFactory As IExportProviderFactory = ExportProviderCache.CreateExportProviderFactory(
+        Private _exportProviderFactory As IExportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
             TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(GetType(StubVsEditorAdaptersFactoryService)))
 
         <WpfFact>

src/VisualStudio/Core/Test/Progression/ProgressionTestHelpers.vb

@@ -11,7 +11,7 @@ Imports <xmlns="http://schemas.microsoft.com/vs/2009/dgml">
 
 Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Progression
     Friend Module ProgressionTestHelpers
-        Public ReadOnly ExportProviderFactory As IExportProviderFactory = ExportProviderCache.CreateExportProviderFactory(
+        Public ReadOnly ExportProviderFactory As IExportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(
             TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(
                 GetType(CSharpProgressionLanguageService),
                 GetType(VisualBasicProgressionLanguageService)))

src/VisualStudio/TestUtilities2/CallHierarchy/CallHierarchyTestState.vb

@@ -24,7 +24,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.CallHierarchy
                 .WithPart(GetType(CallHierarchyProvider)) _
                 .WithPart(GetType(DefaultSymbolMappingService)) _
                 .WithPart(GetType(EditorNotificationServiceFactory))
-        Private Shared ReadOnly ExportProviderFactory As IExportProviderFactory = ExportProviderCache.CreateExportProviderFactory(DefaultCatalog)
+        Private Shared ReadOnly ExportProviderFactory As IExportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory(DefaultCatalog)
 
         Private ReadOnly _commandHandler As CallHierarchyCommandHandler
         Private ReadOnly _presenter As MockCallHierarchyPresenter
@@ -113,7 +113,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.CallHierarchy
             End If
 
             Dim catalog = DefaultCatalog.WithParts(additionalTypes)
-            Return ExportProviderCache.CreateExportProviderFactory(catalog).CreateExportProvider()
+            Return ExportProviderCache.GetOrCreateExportProviderFactory(catalog).CreateExportProvider()
         End Function
 
         Public Shared Function Create(markup As String, ParamArray additionalTypes As Type()) As CallHierarchyTestState

src/VisualStudio/TestUtilities2/VisualStudioTestExportProvider.vb

@@ -12,7 +12,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests
             Dim additionalAssemblies = {GetType(CSharpCodeModelService).Assembly,
                                         GetType(VisualBasicCodeModelService).Assembly}
 
-            Factory = ExportProviderCache.CreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(ExportProviderCache.CreateAssemblyCatalog(additionalAssemblies)))
+            Factory = ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(ExportProviderCache.GetOrCreateAssemblyCatalog(additionalAssemblies)))
         End Sub
 
         Public ReadOnly Property Factory As IExportProviderFactory

src/Workspaces/CoreTest/Host/TestHost.cs

@@ -22,7 +22,7 @@ public static ComposableCatalog Catalog
             {
                 if (s_catalog == null)
                 {
-                    var tmp = ExportProviderCache.CreateAssemblyCatalog(Assemblies);
+                    var tmp = ExportProviderCache.GetOrCreateAssemblyCatalog(Assemblies);
                     System.Threading.Interlocked.CompareExchange(ref s_catalog, tmp, null);
                 }
 

src/Workspaces/CoreTestUtilities/ExportProviderCache.cs

@@ -19,24 +19,24 @@ public static class ExportProviderCache
 
         // Cache the catalog and export provider factory for MefHostServices.DefaultAssemblies
         private static readonly ComposableCatalog s_defaultHostCatalog =
-            CreateAssemblyCatalogNoCache(MefHostServices.DefaultAssemblies);
+            CreateAssemblyCatalog(MefHostServices.DefaultAssemblies);
 
         private static readonly IExportProviderFactory s_defaultHostExportProviderFactory =
-            CreateExportProviderFactoryNoCache(s_defaultHostCatalog);
+            CreateExportProviderFactory(s_defaultHostCatalog);
 
         // Cache the catalog and export provider factory for DesktopMefHostServices.DefaultAssemblies
         private static readonly ComposableCatalog s_desktopHostCatalog =
-            CreateAssemblyCatalogNoCache(DesktopMefHostServices.DefaultAssemblies);
+            CreateAssemblyCatalog(DesktopMefHostServices.DefaultAssemblies);
 
         private static readonly IExportProviderFactory s_desktopHostExportProviderFactory =
-            CreateExportProviderFactoryNoCache(s_desktopHostCatalog);
+            CreateExportProviderFactory(s_desktopHostCatalog);
 
         // Cache the catalog and export provider factory for RoslynServices.RemoteHostAssemblies
         private static readonly ComposableCatalog s_remoteHostCatalog =
-            CreateAssemblyCatalogNoCache(RoslynServices.RemoteHostAssemblies);
+            CreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies);
 
         private static readonly IExportProviderFactory s_remoteHostExportProviderFactory =
-            CreateExportProviderFactoryNoCache(s_remoteHostCatalog);
+            CreateExportProviderFactory(s_remoteHostCatalog);
 
         private static bool _enabled;
 
@@ -59,12 +59,12 @@ internal static void SetEnabled_OnlyUseExportProviderAttributeCanCall(bool value
             }
         }
 
-        public static ComposableCatalog CreateAssemblyCatalog(Assembly assembly)
+        public static ComposableCatalog GetOrCreateAssemblyCatalog(Assembly assembly)
         {
-            return CreateAssemblyCatalog(SpecializedCollections.SingletonEnumerable(assembly));
+            return GetOrCreateAssemblyCatalog(SpecializedCollections.SingletonEnumerable(assembly));
         }
 
-        public static ComposableCatalog CreateAssemblyCatalog(IEnumerable<Assembly> assemblies, Resolver resolver = null)
+        public static ComposableCatalog GetOrCreateAssemblyCatalog(IEnumerable<Assembly> assemblies, Resolver resolver = null)
         {
             if (assemblies is ImmutableArray<Assembly> assembliesArray)
             {
@@ -82,10 +82,10 @@ public static ComposableCatalog CreateAssemblyCatalog(IEnumerable<Assembly> asse
                 }
             }
 
-            return CreateAssemblyCatalogNoCache(assemblies, resolver);
+            return CreateAssemblyCatalog(assemblies, resolver);
         }
 
-        private static ComposableCatalog CreateAssemblyCatalogNoCache(IEnumerable<Assembly> assemblies, Resolver resolver = null)
+        private static ComposableCatalog CreateAssemblyCatalog(IEnumerable<Assembly> assemblies, Resolver resolver = null)
         {
             var discovery = resolver == null ? s_partDiscovery : CreatePartDiscovery(resolver);
 
@@ -138,7 +138,7 @@ public static ComposableCatalog WithPart(this ComposableCatalog catalog, Type t)
             return catalog.WithParts(CreateTypeCatalog(SpecializedCollections.SingletonEnumerable(t)));
         }
 
-        public static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog)
+        public static IExportProviderFactory GetOrCreateExportProviderFactory(ComposableCatalog catalog)
         {
             if (s_defaultHostExportProviderFactory != null && catalog == s_defaultHostCatalog)
             {
@@ -153,10 +153,10 @@ public static IExportProviderFactory CreateExportProviderFactory(ComposableCatal
                 return s_remoteHostExportProviderFactory;
             }
 
-            return CreateExportProviderFactoryNoCache(catalog);
+            return CreateExportProviderFactory(catalog);
         }
 
-        private static IExportProviderFactory CreateExportProviderFactoryNoCache(ComposableCatalog catalog)
+        private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog)
         {
             var configuration = CompositionConfiguration.Create(catalog.WithCompositionService());
             var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
@@ -175,7 +175,7 @@ public SingleExportProviderFactory(ComposableCatalog catalog, IExportProviderFac
                 _exportProviderFactory = exportProviderFactory;
             }
 
-            public ExportProvider CreateExportProvider()
+            public ExportProvider GetOrCreateExportProvider()
             {
                 if (!Enabled)
                 {
@@ -201,6 +201,17 @@ public ExportProvider CreateExportProvider()
                 return exportProvider;
             }
 
+            ExportProvider IExportProviderFactory.CreateExportProvider()
+            {
+                // Currently this implementation deviates from the typical behavior of IExportProviderFactory. For the
+                // duration of a single test, an instance of SingleExportProviderFactory will continue returning the
+                // same ExportProvider instance each time this method is called.
+                //
+                // It may be clearer to refactor the implementation to only allow one call to CreateExportProvider in
+                // the context of a single test. https://github.com/dotnet/roslyn/issues/25863
+                return GetOrCreateExportProvider();
+            }
+
             private static void RequireForSingleExportProvider(bool condition)
             {
                 if (!condition)

src/Workspaces/CoreTestUtilities/UseExportProviderAttribute.cs

@@ -152,10 +152,10 @@ private MefHostServices CreateMefHostServices(IEnumerable<Assembly> assemblies,
                 return _hostServices;
             }
 
-            var catalog = ExportProviderCache.CreateAssemblyCatalog(assemblies);
+            var catalog = ExportProviderCache.GetOrCreateAssemblyCatalog(assemblies);
             Interlocked.CompareExchange(
                 ref _hostServices,
-                new ExportProviderMefHostServices(ExportProviderCache.CreateExportProviderFactory(catalog).CreateExportProvider()),
+                new ExportProviderMefHostServices(ExportProviderCache.GetOrCreateExportProviderFactory(catalog).CreateExportProvider()),
                 null);
 
             return _hostServices;
@@ -174,7 +174,7 @@ private HostServices GetOrCreateRemoteHostServices()
                 {
                     if (s_remoteHostExportProviderFactory == null)
                     {
-                        var configuration = CompositionConfiguration.Create(ExportProviderCache.CreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies).WithCompositionService());
+                        var configuration = CompositionConfiguration.Create(ExportProviderCache.GetOrCreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies).WithCompositionService());
                         var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
                         s_remoteHostExportProviderFactory = runtimeComposition.CreateExportProviderFactory();
                     }