Per-plugin AssemblyLoadContext

Augment MSBuild's handling of assembly loading for plugins (currently tasks,
SDK resolvers, and loggers) to use an AssemblyLoadContext, allowing
plugins to use different versions of dependencies.

Creates a new ALC per assembly path (of initially-loaded assembly, not
indirect dependencies).

Closes #1754. Closes #4635.

src/Build/Microsoft.Build.csproj

@@ -754,6 +754,9 @@
     <Compile Include="..\Shared\TypeLoader.cs">
       <Link>SharedUtilities\TypeLoader.cs</Link>
     </Compile>
+    <Compile Include="..\Shared\MSBuildLoadContext.cs" Condition="'$(TargetFrameworkIdentifier)'!='.NETFramework'">
+      <Link>SharedUtilities\MSBuildLoadContext.cs</Link>
+    </Compile>
     <Compile Include="..\Shared\VisualStudioConstants.cs">
       <Link>VisualStudioConstants.cs</Link>
     </Compile>

src/MSBuild/MSBuild.csproj

@@ -138,6 +138,7 @@
     <Compile Include="..\Shared\OutOfProcTaskHostTaskResult.cs" />
     <Compile Include="..\Shared\TaskHostTaskCancelled.cs" />
     <Compile Include="..\Shared\TaskLoader.cs" />
+    <Compile Include="..\Shared\MSBuildLoadContext.cs" Condition="'$(TargetFrameworkIdentifier)'!='.NETFramework'" />
     <Compile Include="..\Shared\TypeLoader.cs" />
     <Compile Include="..\Shared\LoadedType.cs">
       <ExcludeFromStyleCop>true</ExcludeFromStyleCop>

src/Shared/CoreCLRAssemblyLoader.cs

@@ -5,8 +5,6 @@
 using System.Diagnostics;
 using System.IO;
 using System.Reflection;
-using System.Runtime.Loader;
-using Microsoft.Build.Shared.FileSystem;
 
 namespace Microsoft.Build.Shared
 {
@@ -20,8 +18,6 @@ internal sealed class CoreClrAssemblyLoader
         private readonly HashSet<string> _dependencyPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         private readonly object _guard = new object();
 
-        private bool _resolvingHandlerHookedUp = false;
-
         private static readonly string[] _extensions = new[] { "ni.dll", "ni.exe", "dll", "exe" };
         private static readonly Version _currentAssemblyVersion = new Version(Microsoft.Build.Shared.MSBuildConstants.CurrentAssemblyVersion);
         private static readonly HashSet<string> _wellKnownAssemblyNames = new HashSet<string>(
@@ -57,12 +53,6 @@ public Assembly LoadFromPath(string fullPath)
 
             lock (_guard)
             {
-                if (!_resolvingHandlerHookedUp)
-                {
-                    AssemblyLoadContext.Default.Resolving += TryResolveAssembly;
-                    _resolvingHandlerHookedUp = true;
-                }
-
                 Assembly assembly;
                 if (_pathsToAssemblies.TryGetValue(fullPath, out assembly))
                 {
@@ -150,9 +140,11 @@ private Assembly TryResolveAssemblyFromPaths(AssemblyLoadContext context, Assemb
         /// <remarks>
         /// Assumes we have a lock on _guard
         /// </remarks>
-        private Assembly LoadAndCache(AssemblyLoadContext context, string fullPath)
+        private Assembly LoadAndCache(AssemblyLoadContext _, string fullPath)
         {
-            var assembly = context.LoadFromAssemblyPath(fullPath);
+            var cxt = new MSBuildLoadContext(fullPath);
+
+            var assembly = cxt.LoadFromAssemblyPath(fullPath);
             var name = assembly.FullName;
 
             _pathsToAssemblies[fullPath] = assembly;

src/Shared/MSBuildLoadContext.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Immutable;
+using System.Reflection;
+using System.Runtime.Loader;
+
+#nullable enable
+namespace Microsoft.Build.Shared
+{
+    /// <summary>
+    /// This class is used to isolate the types used by an MSBuild plugin
+    /// (SDK resolver, logger, or task).
+    /// </summary>
+    internal class MSBuildLoadContext : AssemblyLoadContext
+    {
+        private readonly AssemblyDependencyResolver _resolver;
+        private readonly string _directory;
+
+        private static readonly ImmutableHashSet<string> _wellKnownAssemblyNames =
+            new[]
+            {
+                "MSBuild",
+                "Microsoft.Build",
+                "Microsoft.Build.Framework",
+                "Microsoft.Build.Tasks.Core",
+                "Microsoft.Build.Utilities.Core",
+            }.ToImmutableHashSet();
+
+
+        public MSBuildLoadContext(string assemblyPath) :
+            base(name: assemblyPath, isCollectible: false) // TODO: make this collectible?
+        {
+            _directory = assemblyPath;
+            _resolver = new AssemblyDependencyResolver(_directory);
+        }
+
+        protected override Assembly? Load(AssemblyName assemblyName)
+        {
+            if (_wellKnownAssemblyNames.Contains(assemblyName.Name!))
+            {
+                return null;
+            }
+
+            string? assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
+            if (assemblyPath != null)
+            {
+                return LoadFromAssemblyPath(assemblyPath);
+            }
+
+            return null;
+        }
+
+        protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
+        {
+            string? libraryPath = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
+            if (libraryPath != null)
+            {
+                return LoadUnmanagedDllFromPath(libraryPath);
+            }
+
+            return IntPtr.Zero;
+        }
+
+    }
+}