Use a delegate for GetServiceAsync

Rather than extending IGitHubServiceProvider, pass a delegate for GetServiceAsync.

Author: jcansdale

src/GitHub.Exports/Services/IGitHubServiceProvider.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Threading.Tasks;
-using System.Diagnostics.CodeAnalysis;
 using System.ComponentModel.Composition.Hosting;
 using System.Runtime.InteropServices;
 using GitHub.VisualStudio;
@@ -30,20 +28,5 @@ Ret GetService<T, Ret>() where T : class
         /// <param name="owner">The owner, which either has to match what was passed to AddService,
         /// or if it's null, the service will be removed without checking for ownership</param>
         void RemoveService(Type t, object owner);
-
-        /// <summary>
-        /// Gets a Visual Studio service asynchronously.
-        /// </summary>
-        /// <typeparam name="T">The type of the service.</typeparam>
-        Task<T> GetServiceAsync<T>() where T : class;
-
-        /// <summary>
-        /// Gets a Visual Studio service asynchronously.
-        /// </summary>
-        /// <typeparam name="T">The type of the service.</typeparam>
-        /// <typeparam name="Ret">The type of the service instance to return.</typeparam>
-        /// <returns></returns>
-        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]
-        Task<Ret> GetServiceAsync<T, Ret>() where T : class where Ret : class;
     }
 }

src/GitHub.TeamFoundation.14/Services/VSGitExt.cs

@@ -23,22 +23,22 @@ public class VSGitExt : IVSGitExt
     {
         static readonly ILogger log = LogManager.ForContext<VSGitExt>();
 
-        readonly IGitHubServiceProvider serviceProvider;
+        readonly Func<Type, Task<object>> getServiceAsync;
         readonly IVSUIContext context;
         readonly ILocalRepositoryModelFactory repositoryFactory;
 
         IGitExt gitService;
         IReadOnlyList<ILocalRepositoryModel> activeRepositories;
 
         [ImportingConstructor]
-        public VSGitExt(IGitHubServiceProvider serviceProvider)
-            : this(serviceProvider, new VSUIContextFactory(), new LocalRepositoryModelFactory())
+        public VSGitExt(Func<Type, Task<object>> getServiceAsync)
+            : this(getServiceAsync, new VSUIContextFactory(), new LocalRepositoryModelFactory())
         {
         }
 
-        public VSGitExt(IGitHubServiceProvider serviceProvider, IVSUIContextFactory factory, ILocalRepositoryModelFactory repositoryFactory)
+        public VSGitExt(Func<Type, Task<object>> getServiceAsync, IVSUIContextFactory factory, ILocalRepositoryModelFactory repositoryFactory)
         {
-            this.serviceProvider = serviceProvider;
+            this.getServiceAsync = getServiceAsync;
             this.repositoryFactory = repositoryFactory;
 
             // The IGitExt service isn't available when a TFS based solution is opened directly.
@@ -96,7 +96,7 @@ async Task ContextChangedAsync()
 
         async Task<bool> TryInitialize()
         {
-            gitService = await serviceProvider.GetServiceAsync<IGitExt>();
+            gitService = (IGitExt)await getServiceAsync(typeof(IGitExt));
             if (gitService != null)
             {
                 gitService.PropertyChanged += (s, e) =>

src/GitHub.VisualStudio/GitHubPackage.cs

@@ -283,8 +283,7 @@ async Task<object> CreateService(IAsyncServiceContainer container, CancellationT
             else if (serviceType == typeof(IVSGitExt))
             {
                 var dte = await GetServiceAsync(typeof(DTE)) as DTE;
-                var sp = await GetServiceAsync(typeof(IGitHubServiceProvider)) as IGitHubServiceProvider;
-                return CreateVSGitExt(dte.Version, sp);
+                return CreateVSGitExt(dte.Version);
             }
             else if (serviceType == typeof(IGitHubToolWindowManager))
             {
@@ -298,15 +297,15 @@ async Task<object> CreateService(IAsyncServiceContainer container, CancellationT
             }
         }
 
-        IVSGitExt CreateVSGitExt(string dteVersion, IGitHubServiceProvider sp)
+        IVSGitExt CreateVSGitExt(string dteVersion)
         {
             // DTE.Version always ends with ".0" even for later minor versions.
             switch (dteVersion)
             {
                 case "14.0":
-                    return new Lazy<IVSGitExt>(() => new VSGitExt14(sp)).Value;
+                    return new Lazy<IVSGitExt>(() => new VSGitExt14(GetServiceAsync)).Value;
                 case "15.0":
-                    return new Lazy<IVSGitExt>(() => new VSGitExt15(sp)).Value;
+                    return new Lazy<IVSGitExt>(() => new VSGitExt15(GetServiceAsync)).Value;
                 default:
                     log.Error("There is no IVSGitExt implementation for DTE version {Version}", dteVersion);
                     return null;

src/GitHub.VisualStudio/Services/GitHubServiceProvider.cs

@@ -71,10 +71,6 @@ public IServiceProvider GitServiceProvider
         public object TryGetService(Type t) => theRealProvider.TryGetService(t);
 
         public T TryGetService<T>() where T : class => theRealProvider.TryGetService<T>();
-
-        public Task<T> GetServiceAsync<T>() where T : class => theRealProvider.GetServiceAsync<T>();
-
-        public Task<Ret> GetServiceAsync<T, Ret>() where T : class where Ret : class => theRealProvider.GetServiceAsync<T, Ret>();
     }
 
     /// <summary>
@@ -313,8 +309,5 @@ public void Dispose()
             Dispose(true);
             GC.SuppressFinalize(this);
         }
-
-        public async Task<T> GetServiceAsync<T>() where T : class => (T)await asyncServiceProvider.GetServiceAsync(typeof(T));
-        public async Task<Ret> GetServiceAsync<T, Ret>() where T : class where Ret : class => (Ret)await asyncServiceProvider.GetServiceAsync(typeof(T));
     }
 }

test/UnitTests/GitHub.TeamFoundation/VSGitExtTests.cs

@@ -21,25 +21,25 @@ public class TheConstructor : TestBaseClass
         public void GetServiceIGitExt_WhenSccProviderContextIsActive(bool isActive, int expectCalls)
         {
             var context = CreateVSUIContext(isActive);
-            var sp = Substitute.For<IGitHubServiceProvider>();
+            var sp = Substitute.For<IAsyncServiceProvider>();
 
             var target = CreateVSGitExt(context, sp: sp);
 
-            sp.Received(expectCalls).GetServiceAsync<IGitExt>();
+            sp.Received(expectCalls).GetServiceAsync(typeof(IGitExt));
         }
 
         [TestCase(true, 1)]
         [TestCase(false, 0)]
         public void GetServiceIGitExt_WhenUIContextChanged(bool activated, int expectCalls)
         {
             var context = CreateVSUIContext(false);
-            var sp = Substitute.For<IGitHubServiceProvider>();
+            var sp = Substitute.For<IAsyncServiceProvider>();
             var target = CreateVSGitExt(context, sp: sp);
 
             var eventArgs = new VSUIContextChangedEventArgs(activated);
             context.UIContextChanged += Raise.Event<EventHandler<VSUIContextChangedEventArgs>>(context, eventArgs);
 
-            sp.Received(expectCalls).GetServiceAsync<IGitExt>();
+            sp.Received(expectCalls).GetServiceAsync(typeof(IGitExt));
         }
 
         [Test]
@@ -207,23 +207,27 @@ static IReadOnlyList<IGitRepositoryInfo> CreateActiveRepositories(params string[
         return repositories.AsReadOnly();
     }
 
-    static VSGitExt CreateVSGitExt(IVSUIContext context = null, IGitExt gitExt = null, IGitHubServiceProvider sp = null,
+    static VSGitExt CreateVSGitExt(IVSUIContext context = null, IGitExt gitExt = null, IAsyncServiceProvider sp = null,
         ILocalRepositoryModelFactory repoFactory = null)
     {
         context = context ?? CreateVSUIContext(true);
         gitExt = gitExt ?? CreateGitExt();
-        sp = sp ?? Substitute.For<IGitHubServiceProvider>();
+        sp = sp ?? Substitute.For<IAsyncServiceProvider>();
         repoFactory = repoFactory ?? Substitute.For<ILocalRepositoryModelFactory>();
         var factory = Substitute.For<IVSUIContextFactory>();
         var contextGuid = new Guid(Guids.GitSccProviderId);
         factory.GetUIContext(contextGuid).Returns(context);
-        sp.GetService<IVSUIContextFactory>().Returns(factory);
-        sp.GetServiceAsync<IGitExt>().Returns(gitExt);
-        var vsGitExt = new VSGitExt(sp, factory, repoFactory);
+        sp.GetServiceAsync(typeof(IGitExt)).Returns(gitExt);
+        var vsGitExt = new VSGitExt(sp.GetServiceAsync, factory, repoFactory);
         vsGitExt.PendingTasks.Wait();
         return vsGitExt;
     }
 
+    public interface IAsyncServiceProvider
+    {
+        Task<object> GetServiceAsync(Type serviceType);
+    }
+
     static IGitExt CreateGitExt(params string[] repositoryPaths)
     {
         var gitExt = Substitute.For<IGitExt>();