Pass IServiceProvider not IAsyncServiceProvider

There are assemblies with exactly the same IAsyncServiceProvider
namespace + name. Change to use IServiceProvider instead to avoid
having to use assembly aliases. These were getting more complication
with the introduction of Visual Studio 2019 support.

Author: jcansdale

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

@@ -26,26 +26,26 @@ public class VSGitExt : IVSGitExt
     {
         static readonly ILogger log = LogManager.ForContext<VSGitExt>();
 
-        readonly IAsyncServiceProvider asyncServiceProvider;
+        readonly IServiceProvider serviceProvider;
         readonly ILocalRepositoryModelFactory repositoryFactory;
         readonly object refreshLock = new object();
 
         IGitExt gitService;
         IReadOnlyList<ILocalRepositoryModel> activeRepositories;
 
-        public VSGitExt(IAsyncServiceProvider asyncServiceProvider)
-            : this(asyncServiceProvider, new VSUIContextFactory(), new LocalRepositoryModelFactory(), ThreadHelper.JoinableTaskContext)
+        public VSGitExt(IServiceProvider serviceProvider)
+            : this(serviceProvider, new VSUIContextFactory(), new LocalRepositoryModelFactory(), ThreadHelper.JoinableTaskContext)
         {
         }
 
-        public VSGitExt(IAsyncServiceProvider asyncServiceProvider, IVSUIContextFactory factory, ILocalRepositoryModelFactory repositoryFactory,
+        public VSGitExt(IServiceProvider serviceProvider, IVSUIContextFactory factory, ILocalRepositoryModelFactory repositoryFactory,
             JoinableTaskContext joinableTaskContext)
         {
             JoinableTaskCollection = joinableTaskContext.CreateCollection();
             JoinableTaskCollection.DisplayName = nameof(VSGitExt);
             JoinableTaskFactory = joinableTaskContext.CreateFactory(JoinableTaskCollection);
 
-            this.asyncServiceProvider = asyncServiceProvider;
+            this.serviceProvider = serviceProvider;
             this.repositoryFactory = repositoryFactory;
 
             // Start with empty array until we have a chance to initialize.
@@ -133,10 +133,9 @@ public void JoinTillEmpty()
         async Task<T> GetServiceAsync<T>()
         {
             await JoinableTaskFactory.SwitchToMainThreadAsync();
-            return (T)await asyncServiceProvider.GetServiceAsync(typeof(T));
+            return (T)serviceProvider.GetService(typeof(T));
         }
 
-
         public event Action ActiveRepositoriesChanged;
 
         JoinableTaskCollection JoinableTaskCollection { get; }

src/GitHub.VisualStudio/Services/VSGitExtFactory.cs

@@ -4,7 +4,6 @@
 using System;
 using GitHub.Logging;
 using Serilog;
-using Microsoft.VisualStudio.Shell;
 using VSGitExt14 = TF14.GitHub.VisualStudio.Base.VSGitExt;
 using VSGitExt15 = TF15.GitHub.VisualStudio.Base.VSGitExt;
 
@@ -15,23 +14,23 @@ public class VSGitExtFactory
         static readonly ILogger log = LogManager.ForContext<VSGitExtFactory>();
 
         readonly int vsVersion;
-        readonly IAsyncServiceProvider asyncServiceProvider;
+        readonly IServiceProvider serviceProvider;
 
-        public VSGitExtFactory(int vsVersion, IAsyncServiceProvider asyncServiceProvider)
+        public VSGitExtFactory(int vsVersion, IServiceProvider serviceProvider)
         {
             this.vsVersion = vsVersion;
-            this.asyncServiceProvider = asyncServiceProvider;
+            this.serviceProvider = serviceProvider;
         }
 
         public IVSGitExt Create()
         {
             switch (vsVersion)
             {
                 case 14:
-                    return Create(() => new VSGitExt14(asyncServiceProvider));
+                    return Create(() => new VSGitExt14(serviceProvider));
                 case 15:
                 case 16:
-                    return Create(() => new VSGitExt15(asyncServiceProvider));
+                    return Create(() => new VSGitExt15(serviceProvider));
                 default:
                     log.Error("There is no IVSGitExt implementation for DTE version {Version}", vsVersion);
                     return null;

test/GitHub.TeamFoundation.UnitTests/VSGitExtTests.cs

@@ -25,25 +25,25 @@ public class TheConstructor : TestBaseClass
         public void GetServiceIGitExt_WhenGitSccProviderIsActive(bool isActive, string contextGuidString, int expectCalls)
         {
             var context = CreateVSUIContext(isActive);
-            var sp = Substitute.For<IAsyncServiceProvider>();
+            var sp = Substitute.For<IServiceProvider>();
 
             var target = CreateVSGitExt(context, sp: sp, contextGuidString: contextGuidString);
 
-            sp.Received(expectCalls).GetServiceAsync(typeof(IGitExt));
+            sp.Received(expectCalls).GetService(typeof(IGitExt));
         }
 
         [TestCase(true, 1)]
         [TestCase(false, 0)]
         public void GetServiceIGitExt_WhenUIContextChanged(bool activated, int expectCalls)
         {
             var context = CreateVSUIContext(false);
-            var sp = Substitute.For<IAsyncServiceProvider>();
+            var sp = Substitute.For<IServiceProvider>();
             var target = CreateVSGitExt(context, sp: sp);
 
             context.IsActive = activated;
             target.JoinTillEmpty();
 
-            sp.Received(expectCalls).GetServiceAsync(typeof(IGitExt));
+            sp.Received(expectCalls).GetService(typeof(IGitExt));
         }
 
         [Test]
@@ -210,18 +210,18 @@ static IReadOnlyList<IGitRepositoryInfo> CreateActiveRepositories(params string[
         return repositories.AsReadOnly();
     }
 
-    static VSGitExt CreateVSGitExt(IVSUIContext context = null, IGitExt gitExt = null, IAsyncServiceProvider sp = null,
+    static VSGitExt CreateVSGitExt(IVSUIContext context = null, IGitExt gitExt = null, IServiceProvider sp = null,
         ILocalRepositoryModelFactory repoFactory = null, JoinableTaskContext joinableTaskContext = null, string contextGuidString = null)
     {
         context = context ?? CreateVSUIContext(true);
         gitExt = gitExt ?? CreateGitExt();
         var contextGuid = new Guid(contextGuidString ?? Guids.GitSccProviderId);
-        sp = sp ?? Substitute.For<IAsyncServiceProvider>();
+        sp = sp ?? Substitute.For<IServiceProvider>();
         repoFactory = repoFactory ?? Substitute.For<ILocalRepositoryModelFactory>();
         joinableTaskContext = joinableTaskContext ?? new JoinableTaskContext();
         var factory = Substitute.For<IVSUIContextFactory>();
         factory.GetUIContext(contextGuid).Returns(context);
-        sp.GetServiceAsync(typeof(IGitExt)).Returns(gitExt);
+        sp.GetService(typeof(IGitExt)).Returns(gitExt);
         var vsGitExt = new VSGitExt(sp, factory, repoFactory, joinableTaskContext);
         vsGitExt.JoinTillEmpty();
         return vsGitExt;