Perf: use Type instead of string as dictionary key.

This avoids unnecessary calls to AssemblyQualifiedName. (changeset 1248550)

Src/Workspaces/Core/Workspace/Host/Mef/MefHostServices.cs

@@ -23,7 +23,7 @@ public class MefHostServices : HostServices
         private readonly ExportProvider exportProvider;
 
         // accumulated cache for exports
-        private ImmutableDictionary<ExportKey, IEnumerable> exportsMap 
+        private ImmutableDictionary<ExportKey, IEnumerable> exportsMap
             = ImmutableDictionary<ExportKey, IEnumerable>.Empty;
 
         private MefHostServices(ExportProvider exportProvider)
@@ -85,8 +85,8 @@ private class MefWorkspaceServices : HostWorkspaceServices
             private readonly Workspace workspace;
 
             // map of type name to workspace service
-            private ImmutableDictionary<string, IWorkspaceService> serviceMap
-                = ImmutableDictionary<string, IWorkspaceService>.Empty;
+            private ImmutableDictionary<Type, IWorkspaceService> serviceMap
+                = ImmutableDictionary<Type, IWorkspaceService>.Empty;
 
             // accumulated cache for language services
             private ImmutableDictionary<string, MefLanguageServices> languageServicesMap
@@ -113,19 +113,20 @@ public override TWorkspaceService GetService<TWorkspaceService>()
                 IWorkspaceService service;
 
                 var currentMap = this.serviceMap;
-                var key = typeof(TWorkspaceService).AssemblyQualifiedName;
+                var key = typeof(TWorkspaceService);
                 if (!currentMap.TryGetValue(key, out service))
                 {
                     service = ImmutableInterlocked.GetOrAdd(ref this.serviceMap, key, _ =>
                     {
                         // pick from list of exported factories and instances
+                        var serviceType = key.AssemblyQualifiedName;
                         return PickWorkspaceService(
                             this.host.GetExports<IWorkspaceServiceFactory, WorkspaceServiceMetadata>()
-                                .Where(lz => lz.Metadata.ServiceType == key)
+                                .Where(lz => lz.Metadata.ServiceType == serviceType)
                                 .Select(lz => new KeyValuePair<string, Func<MefWorkspaceServices, IWorkspaceService>>(lz.Metadata.Layer, ws => lz.Value.CreateService(ws)))
                                 .Concat(
                             this.host.GetExports<IWorkspaceService, WorkspaceServiceMetadata>()
-                                .Where(lz => lz.Metadata.ServiceType == key)
+                                .Where(lz => lz.Metadata.ServiceType == serviceType)
                                 .Select(lz => new KeyValuePair<string, Func<MefWorkspaceServices, IWorkspaceService>>(lz.Metadata.Layer, ws => lz.Value))));
                     });
                 }
@@ -215,10 +216,10 @@ private class MefLanguageServices : HostLanguageServices
             private readonly ImmutableArray<Lazy<ILanguageService, LanguageServiceMetadata>> services;
             private readonly ImmutableArray<Lazy<ILanguageServiceFactory, LanguageServiceMetadata>> factories;
 
-            private ImmutableDictionary<string, ILanguageService> serviceMap = ImmutableDictionary<string, ILanguageService>.Empty;
+            private ImmutableDictionary<Type, ILanguageService> serviceMap = ImmutableDictionary<Type, ILanguageService>.Empty;
 
             public MefLanguageServices(
-                MefWorkspaceServices workspaceServices, 
+                MefWorkspaceServices workspaceServices,
                 string language)
             {
                 this.workspaceServices = workspaceServices;
@@ -248,24 +249,25 @@ public override TLanguageService GetService<TLanguageService>()
                 ILanguageService service;
 
                 var currentMap = this.serviceMap;
-                var key = typeof(TLanguageService).AssemblyQualifiedName;
+                var key = typeof(TLanguageService);
 
                 if (!currentMap.TryGetValue(key, out service))
                 {
                     service = ImmutableInterlocked.GetOrAdd(ref this.serviceMap, key, _ =>
                     {
                         // pick from list of exported factories and instances
+                        var serviceType = key.AssemblyQualifiedName;
                         return PickLanguageService(
                             this.factories
-                                .Where(lz => lz.Metadata.ServiceType == key)
+                                .Where(lz => lz.Metadata.ServiceType == serviceType)
                                 .Select(lz => new KeyValuePair<string, Func<MefLanguageServices, ILanguageService>>(lz.Metadata.Layer, ls => lz.Value.CreateLanguageService(ls)))
                                 .Concat(
                             this.services
-                                .Where(lz => lz.Metadata.ServiceType == key)
+                                .Where(lz => lz.Metadata.ServiceType == serviceType)
                                 .Select(lz => new KeyValuePair<string, Func<MefLanguageServices, ILanguageService>>(lz.Metadata.Layer, ls => lz.Value))));
                     });
                 }
-               
+
                 return (TLanguageService)service;
             }