Create MEF factory for all exported services

Author: jcansdale

src/GitHub.VisualStudio/GitHub.VisualStudio.csproj

@@ -327,8 +327,6 @@
     <Compile Include="Services\ShowDialogService.cs" />
     <Compile Include="Services\UsageService.cs" />
     <Compile Include="Services\UsageTracker.cs" />
-    <Compile Include="Services\LoginManagerDispatcher.cs" />
-    <Compile Include="Services\UsageTrackerDispatcher.cs" />
     <Compile Include="Services\VSGitExtFactory.cs" />
     <Compile Include="Settings\Constants.cs" />
     <Compile Include="Services\ConnectionManager.cs" />

src/GitHub.VisualStudio/GitHubPackage.cs

@@ -8,6 +8,7 @@
 using GitHub.Api;
 using GitHub.Extensions;
 using GitHub.Info;
+using GitHub.Exports;
 using GitHub.Logging;
 using GitHub.Models;
 using GitHub.Services;
@@ -104,6 +105,38 @@ public GHClient(IProgram program)
         }
     }
 
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class ServiceProviderExports
+    {
+        // Only export services for the Visual Studio process (they don't work in Expression Blend).
+        const string ProcessName = "devenv";
+
+        readonly IServiceProvider serviceProvider;
+
+        [ImportingConstructor]
+        public ServiceProviderExports([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
+        {
+            this.serviceProvider = serviceProvider;
+        }
+
+        [ExportForProcess(typeof(ILoginManager), ProcessName)]
+        public ILoginManager LoginManager => GetService<ILoginManager>();
+
+        [ExportForProcess(typeof(IMenuProvider), ProcessName)]
+        public IMenuProvider MenuProvider => GetService<IMenuProvider>();
+
+        [ExportForProcess(typeof(IGitHubServiceProvider), ProcessName)]
+        public IGitHubServiceProvider GitHubServiceProvider => GetService<IGitHubServiceProvider>();
+
+        [ExportForProcess(typeof(IUsageTracker), ProcessName)]
+        public IUsageTracker UsageTracker => GetService<IUsageTracker>();
+
+        [ExportForProcess(typeof(IVSGitExt), ProcessName)]
+        public IVSGitExt VSGitExt => GetService<IVSGitExt>();
+
+        T GetService<T>() => (T)serviceProvider.GetService(typeof(T));
+    }
+
     [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
     [ProvideService(typeof(ILoginManager), IsAsyncQueryable = true)]
     [ProvideService(typeof(IMenuProvider), IsAsyncQueryable = true)]

src/GitHub.VisualStudio/Menus/MenuProvider.cs

@@ -1,37 +1,8 @@
-using GitHub.Exports;
-using GitHub.Services;
+using GitHub.Services;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.ComponentModel.Composition;
-using System.Linq;
-using System;
-using Microsoft.VisualStudio.Shell;
 
 namespace GitHub.VisualStudio.Menus
 {
-    /// <summary>
-    /// This is a thin MEF wrapper around the MenuProvider
-    /// which is registered as a global VS service. This class just
-    /// redirects every request to the actual service, and can be
-    /// thrown away as soon as the caller is done (no state is kept)
-    /// </summary>
-    [ExportForProcess(typeof(IMenuProvider), "devenv")]
-    [PartCreationPolicy(CreationPolicy.NonShared)]
-    public class MenuProviderDispatcher : IMenuProvider
-    {
-        readonly IMenuProvider theRealProvider;
-
-        [ImportingConstructor]
-        public MenuProviderDispatcher([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
-        {
-            theRealProvider = serviceProvider.GetService(typeof(IMenuProvider)) as IMenuProvider;
-        }
-
-        public IReadOnlyCollection<IDynamicMenuHandler> DynamicMenus => theRealProvider.DynamicMenus;
-
-        public IReadOnlyCollection<IMenuHandler> Menus => theRealProvider.Menus;
-    }
-
     internal class MenuProvider : IMenuProvider
     {
         public IReadOnlyCollection<IMenuHandler> Menus { get; }

src/GitHub.VisualStudio/Services/GitHubServiceProvider.cs

@@ -21,58 +21,6 @@
 
 namespace GitHub.VisualStudio
 {
-    /// <summary>
-    /// This is a thin MEF wrapper around the GitHubServiceProvider
-    /// which is registered as a global VS service. This class just
-    /// redirects every request to the actual service, and can be
-    /// thrown away as soon as the caller is done (no state is kept)
-    /// </summary>
-    [ExportForProcess(typeof(IGitHubServiceProvider), "devenv")]
-    [PartCreationPolicy(CreationPolicy.NonShared)]
-    public class GitHubProviderDispatcher : IGitHubServiceProvider
-    {
-        readonly IGitHubServiceProvider theRealProvider;
-
-        [ImportingConstructor]
-        public GitHubProviderDispatcher([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
-        {
-            theRealProvider = serviceProvider.GetService(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
-        }
-
-        public ExportProvider ExportProvider => theRealProvider.ExportProvider;
-
-        public IServiceProvider GitServiceProvider
-        {
-            get
-            {
-                return theRealProvider.GitServiceProvider;
-            }
-
-            set
-            {
-                theRealProvider.GitServiceProvider = value;
-            }
-        }
-
-        public void AddService(Type t, object owner, object instance) => theRealProvider.AddService(t, owner, instance);
-
-        public void AddService<T>(object owner, T instance) where T : class => theRealProvider.AddService(owner, instance);
-
-        public T GetService<T>() where T : class => theRealProvider.GetService<T>();
-
-        public object GetService(Type serviceType) => theRealProvider.GetService(serviceType);
-
-        public Ret GetService<T, Ret>() where T : class where Ret : class => theRealProvider.GetService<T, Ret>();
-
-        public void RemoveService(Type t, object owner) => theRealProvider.RemoveService(t, owner);
-
-        public object TryGetService(string typename) => theRealProvider.TryGetService(typename);
-
-        public object TryGetService(Type t) => theRealProvider.TryGetService(t);
-
-        public T TryGetService<T>() where T : class => theRealProvider.TryGetService<T>();
-    }
-
     /// <summary>
     /// This is a globally registered service (see `GitHubPackage`).
     /// If you need to access this service via MEF, use the `IGitHubServiceProvider` type

src/GitHub.VisualStudio/Services/LoginManagerDispatcher.cs

@@ -2,8 +2,6 @@
 extern alias TF15;
 
 using System;
-using System.ComponentModel.Composition;
-using GitHub.Info;
 using GitHub.Logging;
 using Serilog;
 using Microsoft.VisualStudio.Shell;
@@ -12,17 +10,10 @@
 
 namespace GitHub.Services
 {
-    [PartCreationPolicy(CreationPolicy.Shared)]
     public class VSGitExtFactory
     {
         static readonly ILogger log = LogManager.ForContext<VSGitExtFactory>();
 
-        [ImportingConstructor]
-        public VSGitExtFactory(IGitHubServiceProvider serviceProvider)
-        {
-            VSGitExt = serviceProvider.GetService<IVSGitExt>();
-        }
-
         public static IVSGitExt Create(int vsVersion, IAsyncServiceProvider sp)
         {
             switch (vsVersion)
@@ -40,8 +31,5 @@ public static IVSGitExt Create(int vsVersion, IAsyncServiceProvider sp)
         // NOTE: We're being careful to only reference VSGitExt14 and VSGitExt15 from inside a lambda expression.
         // This ensures that only the type that's compatible with the running DTE version is loaded.
         static IVSGitExt Create(Func<IVSGitExt> factory) => factory.Invoke();
-
-        [Export]
-        public IVSGitExt VSGitExt { get; }
     }
 }