Merge branch 'master' into refactor/vs-commands

Author: jcansdale

src/GitHub.VisualStudio/GitHub.VisualStudio.csproj

@@ -325,8 +325,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

@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.ComponentModel.Composition;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
@@ -12,6 +13,7 @@
 using GitHub.Extensions;
 using GitHub.Helpers;
 using GitHub.Info;
+using GitHub.Exports;
 using GitHub.Logging;
 using GitHub.Services;
 using GitHub.Services.Vssdk.Commands;
@@ -99,6 +101,38 @@ async Task EnsurePackageLoaded(Guid packageGuid)
         }
     }
 
+    [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(IGitHubServiceProvider), IsAsyncQueryable = true)]
@@ -221,7 +255,7 @@ async Task<object> CreateService(IAsyncServiceContainer container, CancellationT
             else if (serviceType == typeof(IVSGitExt))
             {
                 var vsVersion = ApplicationInfo.GetHostVersionInfo().FileMajorPart;
-                return VSGitExtFactory.Create(vsVersion, this);
+                return new VSGitExtFactory(vsVersion, this).Create();
             }
             else if (serviceType == typeof(IGitHubToolWindowManager))
             {

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,25 +10,27 @@
 
 namespace GitHub.Services
 {
-    [PartCreationPolicy(CreationPolicy.Shared)]
     public class VSGitExtFactory
     {
         static readonly ILogger log = LogManager.ForContext<VSGitExtFactory>();
 
-        [ImportingConstructor]
-        public VSGitExtFactory(IGitHubServiceProvider serviceProvider)
+        readonly int vsVersion;
+        readonly IAsyncServiceProvider asyncServiceProvider;
+
+        public VSGitExtFactory(int vsVersion, IAsyncServiceProvider asyncServiceProvider)
         {
-            VSGitExt = serviceProvider.GetService<IVSGitExt>();
+            this.vsVersion = vsVersion;
+            this.asyncServiceProvider = asyncServiceProvider;
         }
 
-        public static IVSGitExt Create(int vsVersion, IAsyncServiceProvider sp)
+        public IVSGitExt Create()
         {
             switch (vsVersion)
             {
                 case 14:
-                    return Create(() => new VSGitExt14(sp));
+                    return Create(() => new VSGitExt14(asyncServiceProvider));
                 case 15:
-                    return Create(() => new VSGitExt15(sp));
+                    return Create(() => new VSGitExt15(asyncServiceProvider));
                 default:
                     log.Error("There is no IVSGitExt implementation for DTE version {Version}", vsVersion);
                     return null;
@@ -40,8 +40,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; }
     }
 }