Ensure only one binding path for extension

src/GitHub.VisualStudio/GitHub.VisualStudio.csproj

@@ -345,6 +345,7 @@
     <Compile Include="Commands\GoToSolutionOrPullRequestFileCommand.cs" />
     <Compile Include="GitContextPackage.cs" />
     <Compile Include="GitHubPanePackage.cs" />
+    <Compile Include="Helpers\BindingPathHelper.cs" />
     <Compile Include="IServiceProviderPackage.cs" />
     <Compile Include="Helpers\ActiveDocumentSnapshot.cs" />
     <Compile Include="Commands\AddConnectionCommand.cs" />

src/GitHub.VisualStudio/GitHubPackage.cs

@@ -11,6 +11,7 @@
 using GitHub.Logging;
 using GitHub.Services;
 using GitHub.Settings;
+using GitHub.VisualStudio.Helpers;
 using GitHub.VisualStudio.Commands;
 using GitHub.Services.Vssdk.Commands;
 using GitHub.ViewModels.GitHubPane;
@@ -166,18 +167,39 @@ public sealed class ServiceProviderPackage : AsyncPackage, IServiceProviderPacka
         public const string ServiceProviderPackageId = "D5CE1488-DEDE-426D-9E5B-BFCCFBE33E53";
         static readonly ILogger log = LogManager.ForContext<ServiceProviderPackage>();
 
-        protected override Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+        protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
         {
+            await CheckBindingPathsAsync();
+
             AddService(typeof(IGitHubServiceProvider), CreateService, true);
             AddService(typeof(IVSGitExt), CreateService, true);
             AddService(typeof(IUsageTracker), CreateService, true);
             AddService(typeof(IUsageService), CreateService, true);
             AddService(typeof(ILoginManager), CreateService, true);
             AddService(typeof(IGitHubToolWindowManager), CreateService, true);
             AddService(typeof(IPackageSettings), CreateService, true);
-            return Task.CompletedTask;
         }
 
+#if DEBUG
+        async Task CheckBindingPathsAsync()
+        {
+            try
+            {
+                // When running in the Exp instance, ensure there is only one active binding path.
+                // This is necessary when the regular (AllUsers) extension is also installed.
+                // See: https://github.com/github/VisualStudio/issues/2006
+                await JoinableTaskFactory.SwitchToMainThreadAsync();
+                BindingPathHelper.CheckBindingPaths(GetType().Assembly, this);
+            }
+            catch (Exception e)
+            {
+                log.Error(e, nameof(CheckBindingPathsAsync));
+            }
+        }
+#else
+        Task CheckBindingPathsAsync() => Task.CompletedTask;
+#endif
+
         public async Task<IGitHubPaneViewModel> ShowGitHubPane()
         {
             var pane = ShowToolWindow(new Guid(GitHubPane.GitHubPaneGuid));

src/GitHub.VisualStudio/Helpers/BindingPathHelper.cs

@@ -0,0 +1,110 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Diagnostics;
+using System.Globalization;
+using System.Collections.Generic;
+using GitHub.Logging;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Shell.Settings;
+using Microsoft.VisualStudio.Settings;
+using Serilog;
+
+namespace GitHub.VisualStudio.Helpers
+{
+    /// <summary>
+    /// This a workaround for extensions that define a ProvideBindingPath attribute and
+    /// install for AllUsers.
+    /// </summary>
+    /// <remarks>
+    /// Extensions that are installed for AllUsers, will also be installed for all
+    /// instances of Visual Studio - including the experimental (Exp) instance which
+    /// is used in development. This isn't a problem so long as all features that
+    /// exist in the AllUsers extension, also exist in the extension that is being
+    /// developed.
+    /// 
+    /// When an extension uses the ProvideBindingPath attribute, the binding path for
+    /// the AllUsers extension gets installed at the same time as the one in development.
+    /// This doesn't matter when an assembly is strong named and is loaded using its
+    /// full name (including version number). When an assembly is loaded using its
+    /// simple name, assemblies from the AllUsers extension can end up loaded at the
+    /// same time as the extension being developed. This can happen when an assembly
+    /// is loaded from XAML or an .imagemanifest.
+    /// 
+    /// This is a workaround for that issue. The <see cref="FindRedundantBindingPaths(List{string}, string)" />
+    /// method will check to see if a reference assembly could be loaded from an alternative
+    /// binding path. It will return any alternative paths that is finds.
+    /// See https://github.com/github/VisualStudio/issues/1995
+    /// </remarks>
+    public static class BindingPathHelper
+    {
+        static readonly ILogger log = LogManager.ForContext(typeof(BindingPathHelper));
+
+        internal static void CheckBindingPaths(Assembly assembly, IServiceProvider serviceProvider)
+        {
+            log.Information("Looking for assembly on wrong binding path");
+
+            ThreadHelper.CheckAccess();
+            var bindingPaths = FindBindingPaths(serviceProvider);
+            var bindingPath = FindRedundantBindingPaths(bindingPaths, assembly.Location)
+                .FirstOrDefault();
+            if (bindingPath == null)
+            {
+                log.Information("No incorrect binding path found");
+                return;
+            }
+
+            // Log what has been detected
+            log.Warning("Found assembly on wrong binding path {BindingPath}", bindingPath);
+
+            var message = string.Format(CultureInfo.CurrentCulture, @"Found assembly on wrong binding path:
+{0}
+
+Would you like to learn more about this issue?", bindingPath);
+            var action = VsShellUtilities.ShowMessageBox(serviceProvider, message, "GitHub for Visual Studio", OLEMSGICON.OLEMSGICON_WARNING,
+                OLEMSGBUTTON.OLEMSGBUTTON_YESNO, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
+            if (action == 6) // Yes = 6, No = 7
+            {
+                Process.Start("https://github.com/github/VisualStudio/issues/2006");
+            }
+        }
+
+        /// <summary>
+        /// Find any alternative binding path that might have been installed by an AllUsers extension.
+        /// </summary>
+        /// <param name="bindingPaths">A list of binding paths to search</param>
+        /// <param name="assemblyLocation">A reference assembly that has been loaded from the correct path.</param>
+        /// <returns>A list of redundant binding paths.</returns>
+        public static IList<string> FindRedundantBindingPaths(IEnumerable<string> bindingPaths, string assemblyLocation)
+        {
+            var fileName = Path.GetFileName(assemblyLocation);
+            return bindingPaths
+                .Select(p => (path: p, file: Path.Combine(p, fileName)))
+                .Where(pf => File.Exists(pf.file))
+                .Where(pf => !pf.file.Equals(assemblyLocation, StringComparison.OrdinalIgnoreCase))
+                .Select(pf => pf.path)
+                .ToList();
+        }
+
+        /// <summary>
+        /// Find Visual Studio's list of binding paths.
+        /// </summary>
+        /// <returns>A list of binding paths.</returns>
+        public static IEnumerable<string> FindBindingPaths(IServiceProvider serviceProvider)
+        {
+            const string bindingPaths = "BindingPaths";
+            var manager = new ShellSettingsManager(serviceProvider);
+            var store = manager.GetReadOnlySettingsStore(SettingsScope.Configuration);
+            foreach (var guid in store.GetSubCollectionNames(bindingPaths))
+            {
+                var guidPath = Path.Combine(bindingPaths, guid);
+                foreach (var path in store.GetPropertyNames(guidPath))
+                {
+                    yield return path;
+                }
+            }
+        }
+    }
+}

test/GitHub.VisualStudio.UnitTests/GlobalSuppressions.cs

@@ -0,0 +1,10 @@
+
+// This file is used by Code Analysis to maintain SuppressMessage 
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given 
+// a specific target and scoped to a namespace, type, member, etc.
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1034:Nested types should not be visible",
+    Justification = "It's okay for nested unit test types to be visible")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1707:Identifiers should not contain underscores",
+    Justification = "It's okay for unit test names to contain underscores")]

test/GitHub.VisualStudio.UnitTests/Helpers/BindingPathHelperTests.cs

@@ -0,0 +1,38 @@
+using System.IO;
+using System.Collections.Generic;
+using GitHub.VisualStudio.Helpers;
+using NUnit.Framework;
+
+public static class BindingPathHelperTests
+{
+    public class TheFindRedundantBindingPathsMethod
+    {
+        [TestCase]
+        public void Redundant_Binding_Paths_Contains_Alternative_Path()
+        {
+            var alternativeLocation = GetType().Assembly.Location;
+            var fileName = Path.GetFileName(alternativeLocation);
+            var alternativeDir = Path.GetDirectoryName(alternativeLocation);
+            var assemblyDir = @"c:\target";
+            var assemblyLocation = Path.Combine(assemblyDir, fileName);
+            var bindingPaths = new List<string> { alternativeDir, assemblyDir };
+
+            var paths = BindingPathHelper.FindRedundantBindingPaths(bindingPaths, assemblyLocation);
+
+            Assert.That(paths, Contains.Item(alternativeDir));
+            Assert.That(paths, Does.Not.Contain(assemblyDir));
+        }
+
+        [TestCase]
+        public void No_Redundant_Binding_Paths()
+        {
+            var assemblyLocation = GetType().Assembly.Location;
+            var assemblyDir = Path.GetDirectoryName(assemblyLocation);
+            var bindingPaths = new List<string> { assemblyDir };
+
+            var paths = BindingPathHelper.FindRedundantBindingPaths(bindingPaths, assemblyLocation);
+
+            Assert.That(paths, Does.Not.Contain(assemblyDir));
+        }
+    }
+}