diff --git a/src/Features/Core/Portable/CodeFixes/CodeFixService.cs b/src/Features/Core/Portable/CodeFixes/CodeFixService.cs
index 1c186eab3a7d8..34083b2e6f709 100644
--- a/src/Features/Core/Portable/CodeFixes/CodeFixService.cs
+++ b/src/Features/Core/Portable/CodeFixes/CodeFixService.cs
@@ -40,12 +40,11 @@ internal partial class CodeFixService : ICodeFixService
 
         private readonly IDiagnosticAnalyzerService _diagnosticService;
         private readonly ImmutableArray<Lazy<CodeFixProvider, CodeChangeProviderMetadata>> _fixers;
-        private readonly Dictionary<string, List<Lazy<CodeFixProvider, CodeChangeProviderMetadata>>> _fixersPerLanguageMap;
+        private readonly ImmutableDictionary<string, ImmutableArray<Lazy<CodeFixProvider, CodeChangeProviderMetadata>>> _fixersPerLanguageMap;
 
-        private readonly ConditionalWeakTable<IReadOnlyList<AnalyzerReference>, ImmutableDictionary<DiagnosticId, List<CodeFixProvider>>> _projectFixersMap = new();
+        private readonly ConditionalWeakTable<IReadOnlyList<AnalyzerReference>, ImmutableDictionary<DiagnosticId, ImmutableArray<CodeFixProvider>>> _projectFixersMap = new();
 
         // Shared by project fixers and workspace fixers.
-        private readonly Lazy<ImmutableDictionary<CodeFixProvider, CodeChangeProviderMetadata>> _lazyFixerToMetadataMap;
         private readonly ConditionalWeakTable<AnalyzerReference, ProjectCodeFixProvider> _analyzerReferenceToFixersMap = new();
         private readonly ConditionalWeakTable<AnalyzerReference, ProjectCodeFixProvider>.CreateValueCallback _createProjectCodeFixProvider = r => new ProjectCodeFixProvider(r);
         private readonly ImmutableDictionary<LanguageKind, Lazy<ImmutableArray<IConfigurationFixProvider>>> _configurationProvidersMap;
@@ -56,6 +55,7 @@ internal partial class CodeFixService : ICodeFixService
 
         private ImmutableDictionary<CodeFixProvider, ImmutableArray<DiagnosticId>> _fixerToFixableIdsMap = ImmutableDictionary<CodeFixProvider, ImmutableArray<DiagnosticId>>.Empty;
         private ImmutableDictionary<object, FixAllProviderInfo?> _fixAllProviderMap = ImmutableDictionary<object, FixAllProviderInfo?>.Empty;
+        private ImmutableDictionary<CodeFixProvider, CodeChangeProviderMetadata?> _fixerToMetadataMap = ImmutableDictionary<CodeFixProvider, CodeChangeProviderMetadata?>.Empty;
 
         [ImportingConstructor]
         [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
@@ -71,13 +71,9 @@ public CodeFixService(
             _fixers = fixers.ToImmutableArray();
             _fixersPerLanguageMap = _fixers.ToPerLanguageMapWithMultipleLanguages();
 
-            _lazyFixerToMetadataMap = new(() => fixers.Where(service => service.IsValueCreated).ToImmutableDictionary(service => service.Value, service => service.Metadata));
-
             _configurationProvidersMap = GetConfigurationProvidersPerLanguageMap(configurationProviders);
         }
 
-        private ImmutableDictionary<CodeFixProvider, CodeChangeProviderMetadata> FixerToMetadataMap => _lazyFixerToMetadataMap.Value;
-
         public async Task<FirstDiagnosticResult> GetMostSevereFixableDiagnosticAsync(
             Document document, TextSpan range, CancellationToken cancellationToken)
         {
@@ -433,7 +429,7 @@ await AppendFixesOrConfigurationsAsync(
                         getFixes: dxs =>
                         {
                             var fixerName = fixer.GetType().Name;
-                            FixerToMetadataMap.TryGetValue(fixer, out var fixerMetadata);
+                            var fixerMetadata = TryGetMetadata(fixer);
 
                             using (addOperationScope(fixerName))
                             using (RoslynEventSource.LogInformationalBlock(FunctionId.CodeFixes_GetCodeFixesAsync, fixerName, cancellationToken))
@@ -468,6 +464,27 @@ await AppendFixesOrConfigurationsAsync(
             }
         }
 
+        private CodeChangeProviderMetadata? TryGetMetadata(CodeFixProvider fixer)
+        {
+            return ImmutableInterlocked.GetOrAdd(
+                ref _fixerToMetadataMap,
+                fixer,
+                static (fixer, fixers) =>
+                {
+                    foreach (var lazy in fixers)
+                    {
+                        if (lazy.IsValueCreated && lazy.Value == fixer)
+                            return lazy.Metadata;
+                    }
+
+                    // Note: it feels very strange that we could ever not find a fixer in our list.  However, this
+                    // occurs in testing scenarios.  I'm not sure if the tests represent a bogus potential input, or if
+                    // this is something that can actually occur in practice and we want to keep working.
+                    return null;
+                },
+                _fixers);
+        }
+
         private static async Task<ImmutableArray<CodeFix>> GetCodeFixesAsync(
             Document document, TextSpan span, CodeFixProvider fixer, CodeChangeProviderMetadata? fixerMetadata, CodeActionOptions options,
             ImmutableArray<Diagnostic> diagnostics,
@@ -611,7 +628,7 @@ await diagnosticsWithSameSpan.OrderByDescending(d => d.Severity)
             }
 
             // If the fix provider supports fix all occurrences, then get the corresponding FixAllProviderInfo and fix all context.
-            var fixAllProviderInfo = extensionManager.PerformFunction<FixAllProviderInfo?>(fixer, () => ImmutableInterlocked.GetOrAdd(ref _fixAllProviderMap, fixer, FixAllProviderInfo.Create), defaultValue: null);
+            var fixAllProviderInfo = extensionManager.PerformFunction(fixer, () => ImmutableInterlocked.GetOrAdd(ref _fixAllProviderMap, fixer, FixAllProviderInfo.Create), defaultValue: null);
 
             FixAllState? fixAllState = null;
             var supportedScopes = ImmutableArray<FixAllScope>.Empty;
@@ -840,7 +857,7 @@ private ImmutableDictionary<LanguageKind, Lazy<ImmutableDictionary<DiagnosticId,
             {
                 var lazyMap = new Lazy<ImmutableDictionary<DiagnosticId, ImmutableArray<CodeFixProvider>>>(() =>
                 {
-                    var mutableMap = new Dictionary<DiagnosticId, List<CodeFixProvider>>();
+                    using var _ = PooledDictionary<DiagnosticId, ArrayBuilder<CodeFixProvider>>.GetInstance(out var mutableMap);
 
                     foreach (var lazyFixer in lazyFixers)
                     {
@@ -856,18 +873,12 @@ private ImmutableDictionary<LanguageKind, Lazy<ImmutableDictionary<DiagnosticId,
                                 continue;
                             }
 
-                            var list = mutableMap.GetOrAdd(id, static _ => new List<CodeFixProvider>());
+                            var list = mutableMap.GetOrAdd(id, static _ => ArrayBuilder<CodeFixProvider>.GetInstance());
                             list.Add(fixer);
                         }
                     }
 
-                    var immutableMap = ImmutableDictionary.CreateBuilder<DiagnosticId, ImmutableArray<CodeFixProvider>>();
-                    foreach (var (diagnosticId, fixers) in mutableMap)
-                    {
-                        immutableMap.Add(diagnosticId, fixers.AsImmutableOrEmpty());
-                    }
-
-                    return immutableMap.ToImmutable();
+                    return mutableMap.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableAndFree());
                 }, isThreadSafe: true);
 
                 fixerMap = fixerMap.Add(diagnosticId, lazyMap);
@@ -890,7 +901,7 @@ private static ImmutableDictionary<LanguageKind, Lazy<ImmutableArray<IConfigurat
 
             return configurationFixerMap.ToImmutable();
 
-            static ImmutableArray<IConfigurationFixProvider> GetConfigurationFixProviders(List<Lazy<IConfigurationFixProvider, CodeChangeProviderMetadata>> languageKindAndFixers)
+            static ImmutableArray<IConfigurationFixProvider> GetConfigurationFixProviders(ImmutableArray<Lazy<IConfigurationFixProvider, CodeChangeProviderMetadata>> languageKindAndFixers)
             {
                 using var builderDisposer = ArrayBuilder<IConfigurationFixProvider>.GetInstance(out var builder);
                 var orderedLanguageKindAndFixers = ExtensionOrderer.Order(languageKindAndFixers);
@@ -932,19 +943,19 @@ private ImmutableDictionary<LanguageKind, Lazy<ImmutableDictionary<CodeFixProvid
             return languageMap.ToImmutable();
         }
 
-        private ImmutableDictionary<DiagnosticId, List<CodeFixProvider>> GetProjectFixers(Project project)
+        private ImmutableDictionary<DiagnosticId, ImmutableArray<CodeFixProvider>> GetProjectFixers(Project project)
         {
             // TODO (https://github.com/dotnet/roslyn/issues/4932): Don't restrict CodeFixes in Interactive
             return project.Solution.Workspace.Kind == WorkspaceKind.Interactive
-                ? ImmutableDictionary<DiagnosticId, List<CodeFixProvider>>.Empty
+                ? ImmutableDictionary<DiagnosticId, ImmutableArray<CodeFixProvider>>.Empty
                 : _projectFixersMap.GetValue(project.AnalyzerReferences, _ => ComputeProjectFixers(project));
         }
 
-        private ImmutableDictionary<DiagnosticId, List<CodeFixProvider>> ComputeProjectFixers(Project project)
+        private ImmutableDictionary<DiagnosticId, ImmutableArray<CodeFixProvider>> ComputeProjectFixers(Project project)
         {
             var extensionManager = project.Solution.Workspace.Services.GetService<IExtensionManager>();
 
-            var builder = ImmutableDictionary.CreateBuilder<DiagnosticId, List<CodeFixProvider>>();
+            using var _ = PooledDictionary<DiagnosticId, ArrayBuilder<CodeFixProvider>>.GetInstance(out var builder);
             foreach (var reference in project.AnalyzerReferences)
             {
                 var projectCodeFixerProvider = _analyzerReferenceToFixersMap.GetValue(reference, _createProjectCodeFixProvider);
@@ -956,13 +967,13 @@ private ImmutableDictionary<DiagnosticId, List<CodeFixProvider>> ComputeProjectF
                         if (string.IsNullOrWhiteSpace(id))
                             continue;
 
-                        var list = builder.GetOrAdd(id, static _ => new List<CodeFixProvider>());
+                        var list = builder.GetOrAdd(id, static _ => ArrayBuilder<CodeFixProvider>.GetInstance());
                         list.Add(fixer);
                     }
                 }
             }
 
-            return builder.ToImmutable();
+            return builder.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableAndFree());
         }
     }
 }
diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ILanguageMetadataExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/ILanguageMetadataExtensions.cs
index b67e08139188d..2693c87039496 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/ILanguageMetadataExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/ILanguageMetadataExtensions.cs
@@ -41,10 +41,10 @@ public static ImmutableDictionary<string, ImmutableArray<Lazy<TInterface, TMetad
             return builder.Select(kvp => new KeyValuePair<string, ImmutableArray<Lazy<TInterface, TMetadata>>>(kvp.Key, kvp.Value.ToImmutableAndFree())).ToImmutableDictionary();
         }
 
-        public static Dictionary<string, List<Lazy<TInterface, TMetadata>>> ToPerLanguageMapWithMultipleLanguages<TInterface, TMetadata>(this IEnumerable<Lazy<TInterface, TMetadata>> services)
+        public static ImmutableDictionary<string, ImmutableArray<Lazy<TInterface, TMetadata>>> ToPerLanguageMapWithMultipleLanguages<TInterface, TMetadata>(this IEnumerable<Lazy<TInterface, TMetadata>> services)
             where TMetadata : ILanguagesMetadata
         {
-            var map = new Dictionary<string, List<Lazy<TInterface, TMetadata>>>();
+            using var _ = PooledDictionary<string, ArrayBuilder<Lazy<TInterface, TMetadata>>>.GetInstance(out var map);
 
             foreach (var service in services)
             {
@@ -52,13 +52,13 @@ public static Dictionary<string, List<Lazy<TInterface, TMetadata>>> ToPerLanguag
                 {
                     if (!string.IsNullOrEmpty(language))
                     {
-                        var list = map.GetOrAdd(language, _ => new List<Lazy<TInterface, TMetadata>>());
+                        var list = map.GetOrAdd(language, _ => ArrayBuilder<Lazy<TInterface, TMetadata>>.GetInstance());
                         list.Add(service);
                     }
                 }
             }
 
-            return map;
+            return map.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableAndFree());
         }
     }
 }