Assembly scanner can load types more than once from different AssemblyLoadContexts (#7620)

* Prevent assembly scanner results from having duplicate assemblies and types (#7617)

* Add test to reproduce the bug

* Use ALC to load referenced assemblies

* Use ALC as part of assembly identity

* Consider ALC when deduping scanner results

---------

Co-authored-by: Daniel Marbach <danielmarbach@users.noreply.github.com>

* Fix code analysis for Compile Remove instruction (#7615)

---------

Co-authored-by: Brandon Ording <bording@gmail.com>
Co-authored-by: Daniel Marbach <danielmarbach@users.noreply.github.com>

Author: 3 people

src/NServiceBus.Core.Tests/AssemblyScanner/When_more_than_one_AssemblyLoadContext_has_scannable_types.cs

@@ -0,0 +1,45 @@
+namespace NServiceBus.Core.Tests.AssemblyScanner;
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Runtime.Loader;
+using Hosting.Helpers;
+using NUnit.Framework;
+
+[TestFixture]
+public class When_more_than_one_AssemblyLoadContext_has_scannable_types
+{
+    [Test]
+    public void Should_only_load_one_copy_of_the_assembly()
+    {
+        var scanPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestDlls", "Messages");
+        var customAssemblyLoadContext = new AssemblyLoadContext("ScannerTestALC", isCollectible: true);
+
+        customAssemblyLoadContext.LoadFromAssemblyPath(Path.Combine(scanPath, "Messages.Referencing.Core.dll"));
+
+        var scanner = new AssemblyScanner(scanPath);
+        var result = scanner.GetScannableAssemblies();
+
+        var loadedFromScanPath = result.Assemblies
+            .Where(a =>
+                !string.IsNullOrWhiteSpace(a.Location) &&
+                a.Location.StartsWith(scanPath, StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        Assert.That(loadedFromScanPath, Is.Not.Empty, "Expected at least one assembly to be loaded from the scan directory.");
+
+        var assemblies = loadedFromScanPath.GroupBy(a => a.FullName);
+
+        foreach (var assembly in assemblies)
+        {
+            var numberOfTimesLoaded = assembly.Count();
+            Assert.That(numberOfTimesLoaded, Is.EqualTo(1), $"Assembly {assembly.Key} was loaded from more than one AssemblyLoadContext.");
+        }
+
+        var messagesAssembly = loadedFromScanPath.Single(a => a.FullName.StartsWith("Messages.Referencing.Core"));
+        var loadContext = AssemblyLoadContext.GetLoadContext(messagesAssembly);
+
+        Assert.That(loadContext.Name, Is.EqualTo("ScannerTestALC"), "The wrong AssemblyLoadContext was used to load the assembly.");
+    }
+}

src/NServiceBus.Core/Hosting/Helpers/AssemblyScanner.cs

@@ -72,10 +72,10 @@ internal IReadOnlyCollection<Type> TypesToSkip
     public AssemblyScannerResults GetScannableAssemblies()
     {
         var results = new AssemblyScannerResults();
-        var processed = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase)
+        var processed = new Dictionary<AssemblyIdentity, bool>
         {
-            { GetType().Assembly.FullName!, true },
-            { typeof(ICommand).Assembly.FullName!, true },
+            { GetAssemblyIdentity(GetType().Assembly), true },
+            { GetAssemblyIdentity(typeof(ICommand).Assembly), true },
         };
 
         if (assemblyToScan is not null)
@@ -200,47 +200,51 @@ bool TryLoadScannableAssembly(string assemblyPath, AssemblyScannerResults result
         }
     }
 
-    bool ScanAssembly(Assembly assembly, Dictionary<string, bool> processed)
+    bool ScanAssembly(Assembly assembly, Dictionary<AssemblyIdentity, bool> processed)
     {
         if (assembly.FullName is null)
         {
             return false;
         }
 
-        if (processed.TryGetValue(assembly.FullName, out var value))
+        var identity = GetAssemblyIdentity(assembly);
+
+        if (processed.TryGetValue(identity, out var value))
         {
             return value;
         }
 
-        processed[assembly.FullName] = false;
+        processed[identity] = false;
 
         if (ShouldScanDependencies(assembly))
         {
+            var context = AssemblyLoadContext.GetLoadContext(assembly);
+
             foreach (var referencedAssemblyName in assembly.GetReferencedAssemblies())
             {
-                var referencedAssembly = GetReferencedAssembly(referencedAssemblyName);
+                var referencedAssembly = GetReferencedAssembly(context, referencedAssemblyName);
                 if (referencedAssembly is not null)
                 {
                     var referencesCore = ScanAssembly(referencedAssembly, processed);
                     if (referencesCore)
                     {
-                        processed[assembly.FullName] = true;
+                        processed[identity] = true;
                         break;
                     }
                 }
             }
         }
 
-        return processed[assembly.FullName];
+        return processed[identity];
     }
 
-    static Assembly? GetReferencedAssembly(AssemblyName assemblyName)
+    static Assembly? GetReferencedAssembly(AssemblyLoadContext? context, AssemblyName assemblyName)
     {
         Assembly? referencedAssembly = null;
 
         try
         {
-            referencedAssembly = Assembly.Load(assemblyName);
+            referencedAssembly = context?.LoadFromAssemblyName(assemblyName);
         }
         catch (Exception ex) when (ex is FileNotFoundException or BadImageFormatException or FileLoadException) { }
 
@@ -411,4 +415,9 @@ bool ShouldScanDependencies(Assembly assembly)
         // And other windows azure stuff
         "Microsoft.WindowsAzure"
     }.ToFrozenSet(StringComparer.OrdinalIgnoreCase);
+
+    static AssemblyIdentity GetAssemblyIdentity(Assembly assembly) =>
+      new(assembly.FullName!, AssemblyLoadContext.GetLoadContext(assembly));
+
+    readonly record struct AssemblyIdentity(string FullName, AssemblyLoadContext? LoadContext);
 }

src/NServiceBus.Core/Hosting/Helpers/AssemblyScannerResults.cs

@@ -5,6 +5,7 @@ namespace NServiceBus.Hosting.Helpers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Loader;
 
 /// <summary>
 /// Holds <see cref="AssemblyScanner.GetScannableAssemblies" /> results.
@@ -46,7 +47,44 @@ public AssemblyScannerResults()
 
     internal void RemoveDuplicates()
     {
-        Assemblies = [.. Assemblies.Distinct()];
-        Types = [.. Types.Distinct()];
+        if (AssemblyLoadContext.All.Count() == 1)
+        {
+            Assemblies = [.. Assemblies.Distinct()];
+            Types = [.. Types.Distinct()];
+
+            return;
+        }
+
+        var preferredAssemblies = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var assembly in Assemblies)
+        {
+            var fullName = assembly.FullName;
+
+            if (fullName is null)
+            {
+                continue;
+            }
+
+            if (!preferredAssemblies.TryGetValue(fullName, out var existing))
+            {
+                preferredAssemblies[fullName] = assembly;
+                continue;
+            }
+
+            preferredAssemblies[fullName] = PreferAssembly(existing, assembly);
+        }
+
+        Assemblies = [.. preferredAssemblies.Values];
+
+        var assemblySet = Assemblies.ToHashSet();
+        Types = [.. Types.Where(t => assemblySet.Contains(t.Assembly)).Distinct()];
+    }
+
+    static Assembly PreferAssembly(Assembly left, Assembly right)
+    {
+        var leftIsDefault = AssemblyLoadContext.GetLoadContext(left) == AssemblyLoadContext.Default;
+
+        return leftIsDefault ? right : left;
     }
 }

src/NServiceBus.Core/NServiceBus.Core.csproj

@@ -33,7 +33,7 @@
   </PropertyGroup>
 
   <ItemGroup Label="Remove this ItemGroup when FastExpressionCompiler stops included test code in the package">
-    <Compile Remove="$(PkgFastExpressionCompiler_Internal_src)\**\TestTools.cs" />
+    <Compile Remove="$(PkgFastExpressionCompiler_Internal_src)\**\TestTools.cs" Condition="'$(PkgFastExpressionCompiler_Internal_src)' != ''" />
   </ItemGroup>
 
   <ItemGroup>