Do initialization asynchronously on Main thread

This will allow this service to be used by a package that is initializing on a background thread.

Author: jcansdale

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

@@ -6,6 +6,7 @@
 using GitHub.Models;
 using GitHub.Services;
 using GitHub.Logging;
+using GitHub.Helpers;
 using GitHub.TeamFoundation.Services;
 using Serilog;
 using Microsoft.VisualStudio.TeamFoundation.Git.Extensibility;
@@ -46,45 +47,72 @@ public VSGitExt(IGitHubServiceProvider serviceProvider, IVSUIContextFactory fact
             // Start with empty array until we have a chance to initialize.
             ActiveRepositories = Array.Empty<ILocalRepositoryModel>();
 
-            if (context.IsActive && TryInitialize())
+            PendingTasks = InitializeAsync();
+        }
+
+        async Task InitializeAsync()
+        {
+            try
             {
-                // Refresh ActiveRepositories on background thread so we don't delay startup.
-                QueueRefreshActiveRepositories();
+                if (!context.IsActive || !await TryInitialize())
+                {
+                    // If we're not in the UIContext or TryInitialize fails, have another go when the UIContext changes.
+                    context.UIContextChanged += ContextChanged;
+                    log.Debug("VSGitExt will be initialized later");
+                }
             }
-            else
+            catch (Exception e)
             {
-                // If we're not in the UIContext or TryInitialize fails, have another go when the UIContext changes.
-                context.UIContextChanged += ContextChanged;
-                log.Debug("VSGitExt will be initialized later");
+                log.Error(e, "Initializing");
             }
         }
 
         void ContextChanged(object sender, VSUIContextChangedEventArgs e)
         {
-            // If we're in the UIContext and TryInitialize succeeds, we can stop listening for events.
-            // NOTE: this event can fire with UIContext=true in a TFS solution (not just Git).
-            if (e.Activated && TryInitialize())
+            if (e.Activated)
             {
-                // Refresh ActiveRepositories on background thread so we don't delay UI context change.
-                QueueRefreshActiveRepositories();
-                context.UIContextChanged -= ContextChanged;
-                log.Debug("Initialized VSGitExt on UIContextChanged");
+                PendingTasks = ContextChangedAsync();
             }
         }
 
-        bool TryInitialize()
+        async Task ContextChangedAsync()
         {
+            try
+            {
+                // If we're in the UIContext and TryInitialize succeeds, we can stop listening for events.
+                // NOTE: this event can fire with UIContext=true in a TFS solution (not just Git).
+                if (await TryInitialize())
+                {
+                    context.UIContextChanged -= ContextChanged;
+                    log.Debug("Initialized VSGitExt on UIContextChanged");
+                }
+            }
+            catch (Exception e)
+            {
+                log.Error(e, "UIContextChanged");
+            }
+        }
+
+        async Task<bool> TryInitialize()
+        {
+            // GetService must be called on the Main thread.
+            await ThreadingHelper.SwitchToMainThreadAsync();
+
             gitService = serviceProvider.GetService<IGitExt>();
             if (gitService != null)
             {
                 gitService.PropertyChanged += (s, e) =>
                 {
                     if (e.PropertyName == nameof(gitService.ActiveRepositories))
                     {
-                        QueueRefreshActiveRepositories();
+                        // Execute tasks in sequence using thread pool (TaskScheduler.Default).
+                        PendingTasks = PendingTasks.ContinueWith(_ => RefreshActiveRepositories(), TaskScheduler.Default);
                     }
                 };
 
+                // Do this after we start listening so we don't miss an event.
+                await Task.Run(() => RefreshActiveRepositories());
+
                 log.Debug("Found IGitExt service and initialized VSGitExt");
                 return true;
             }
@@ -93,12 +121,6 @@ bool TryInitialize()
             return false;
         }
 
-        void QueueRefreshActiveRepositories()
-        {
-            // Execute tasks in sequence using thread pool (TaskScheduler.Default).
-            PendingTasks = PendingTasks.ContinueWith(_ => RefreshActiveRepositories(), TaskScheduler.Default);
-        }
-
         void RefreshActiveRepositories()
         {
             try
@@ -140,6 +162,6 @@ private set
         /// <summary>
         /// Tasks that are pending execution on the thread pool.
         /// </summary>
-        public Task PendingTasks { get; private set; } = Task.CompletedTask;
+        public Task PendingTasks { get; private set; }
     }
 }

test/UnitTests/GitHub.TeamFoundation/VSGitExtTests.cs

@@ -11,11 +11,10 @@
 using Microsoft.VisualStudio.TeamFoundation.Git.Extensibility;
 using System.Threading.Tasks;
 using System.Linq;
-using GitHub.TeamFoundation.Services;
 
 public class VSGitExtTests
 {
-    public class TheConstructor
+    public class TheConstructor : TestBaseClass
     {
         [TestCase(true, 1)]
         [TestCase(false, 0)]
@@ -60,7 +59,7 @@ public void ActiveRepositories_ReadUsingThreadPoolThread()
         }
     }
 
-    public class TheActiveRepositoriesChangedEvent
+    public class TheActiveRepositoriesChangedEvent : TestBaseClass
     {
         [Test]
         public async Task GitExtPropertyChangedEvent_ActiveRepositoriesChangedIsFired()
@@ -132,7 +131,7 @@ public void WhenUIContextChanged_FiredUsingThreadPoolThread()
         }
     }
 
-    public class TheActiveRepositoriesProperty
+    public class TheActiveRepositoriesProperty : TestBaseClass
     {
         [Test]
         public void SccProviderContextNotActive_IsEmpty()