Enhanced assembly resolution for windows and aspnetcore

CharliePoole · CharliePoole · commit 771e7d04ca96 · 2025-11-24T02:27:26.000-08:00
diff --git a/src/NUnitEngine/nunit.engine.core/DotNetHelper.cs b/src/NUnitEngine/nunit.engine.core/DotNetHelper.cs
@@ -2,65 +2,113 @@
 
 using Microsoft.Win32;
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing.Drawing2D;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 
 namespace NUnit.Engine
 {
     public static class DotNet
     {
-        public static string GetInstallDirectory() => Environment.Is64BitProcess
-            ? GetX64InstallDirectory() : GetX86InstallDirectory();
+        private const string X64_SUBKEY1 = @"SOFTWARE\dotnet\SetUp\InstalledVersions\x64\sharedHost\";
+        private const string X64_SUBKEY2 = @"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x64\";
+        private const string X86_SUBKEY1 = @"SOFTWARE\dotnet\SetUp\InstalledVersions\x86\InstallLocation\";
+        private const string X86_SUBKEY2 = @"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x86\";
 
-        public static string GetInstallDirectory(bool x86) => x86
-            ? GetX86InstallDirectory() : GetX64InstallDirectory();
+        public static readonly string X64InstallDirectory;
+        public static readonly string X86InstallDirectory;
+        public static readonly List<RuntimeInfo> Runtimes;
 
-        private static string _x64InstallDirectory;
-        public static string GetX64InstallDirectory()
+        public class RuntimeInfo
         {
-            if (_x64InstallDirectory == null)
-                _x64InstallDirectory = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+            public string Name;
+            public Version Version;
+            public string Path;
+
+            public RuntimeInfo(string name, string version, string path)
+                : this(name, new Version(version), path) { }
 
-            if (_x64InstallDirectory == null)
+            public RuntimeInfo(string name, Version version, string path)
             {
-#if NETFRAMEWORK
-                if (Path.DirectorySeparatorChar == '\\')
-#else
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-#endif
-                {
-                    RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\dotnet\SetUp\InstalledVersions\x64\sharedHost\");
-                    _x64InstallDirectory = (string)key?.GetValue("Path");
-                }
-                else
-                    _x64InstallDirectory = "/usr/shared/dotnet/";
+                Name = name;
+                Version = version;
+                Path = path;
             }
-
-            return _x64InstallDirectory;
         }
 
-        private static string _x86InstallDirectory;
-        public static string GetX86InstallDirectory()
+        /// <summary>
+        /// Static constructor initializes everything once
+        /// </summary>
+        static DotNet()
         {
-            if (_x86InstallDirectory == null)
-                _x86InstallDirectory = Environment.GetEnvironmentVariable("DOTNET_ROOT_X86");
+#pragma warning disable CA1416
+            X64InstallDirectory = 
+                Environment.GetEnvironmentVariable("DOTNET_ROOT") ?? (
+                    IsWindows
+                        ? (string)Registry.LocalMachine.OpenSubKey(X64_SUBKEY1)?.GetValue("Path") ??
+                          (string)Registry.LocalMachine.OpenSubKey(X64_SUBKEY2)?.GetValue("Path") ?? @"C:\Program Files\dotnet"
+                        : "/usr/shared/dotnet/");
+            X86InstallDirectory = 
+                Environment.GetEnvironmentVariable("DOTNET_ROOT_X86") ?? (
+                    IsWindows
+                        ? (string)Registry.LocalMachine.OpenSubKey(X86_SUBKEY1)?.GetValue("InstallLocation") ??
+                          (string)Registry.LocalMachine.OpenSubKey(X86_SUBKEY2)?.GetValue("InstallLocation") ?? @"C:\Program Files (x86)\dotnet"
+                        : "/usr/shared/dotnet/");
+#pragma warning restore CA1416
+            Runtimes = new List<RuntimeInfo>();
+            foreach (string line in DotnetCommand("--list-runtimes"))
+            {
+                string[] parts = line.Trim().Split([' '], 3);
+                Runtimes.Add(new RuntimeInfo(parts[0], parts[1], parts[2].Trim(['[', ']'])));
+            }
+        }
+
+        /// <summary>
+        /// Get the correct install directory, depending on whether we need X86 or X64 architecture.
+        /// </summary>
+        /// <param name="x86">Flag indicating whether the X86 architecture is needed</param>
+        /// <returns></returns>
+        public static string GetInstallDirectory(bool x86) => x86
+            ? X86InstallDirectory : X64InstallDirectory;
+
+        public static IEnumerable<RuntimeInfo> GetRuntimes(string name) => Runtimes.Where(r => r.Name == name);
 
-            if (_x86InstallDirectory == null)
+        private static IEnumerable<string> DotnetCommand(string arguments)
+        {
+            var process = new Process
             {
-#if NETFRAMEWORK
-                if (Path.DirectorySeparatorChar == '\\')
-#else
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-#endif
+                StartInfo = new ProcessStartInfo
                 {
-                    RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x86\");
-                    _x86InstallDirectory = (string)key?.GetValue("InstallLocation");
+                    FileName = "dotnet",
+                    Arguments = arguments,
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true,
+                    CreateNoWindow = true
                 }
-                else
-                    _x86InstallDirectory = "/usr/shared/dotnet/";
+            };
+
+            try
+            {
+                process.Start();
+            }
+            catch (Exception)
+            {
+                // Failed to start dotnet command. Assume no versions are installed and just return
+                yield break;
             }
 
-            return _x86InstallDirectory;
+            while (!process.StandardOutput.EndOfStream)
+                yield  return process.StandardOutput.ReadLine();
         }
+
+#if NETFRAMEWORK
+        private static bool IsWindows => Path.DirectorySeparatorChar == '\\';
+#else
+        private static bool IsWindows => RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+#endif
+
     }
 }
diff --git a/src/NUnitEngine/nunit.engine.core/Internal/TestAssemblyResolver.cs b/src/NUnitEngine/nunit.engine.core/Internal/TestAssemblyResolver.cs
@@ -7,6 +7,7 @@
 using Microsoft.Win32;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -22,59 +23,57 @@ internal sealed class TestAssemblyResolver : IDisposable
 
         private readonly AssemblyLoadContext _loadContext;
 
-        private static readonly string INSTALL_DIR;
-        private static readonly string WINDOWS_DESKTOP_DIR;
-        private static readonly string ASP_NET_CORE_DIR;
+        private readonly IEnumerable<DotNet.RuntimeInfo> _windowsDesktopRuntimes;
+        private readonly IEnumerable<DotNet.RuntimeInfo> _aspNetCoreRuntimes;
 
         // Our Strategies for resolving references
         List<ResolutionStrategy> ResolutionStrategies;
 
-        static TestAssemblyResolver()
-        {
-            INSTALL_DIR = DotNet.GetInstallDirectory();
-            WINDOWS_DESKTOP_DIR = Path.Combine(INSTALL_DIR, "shared", "Microsoft.WindowsDesktop.App");
-            ASP_NET_CORE_DIR = Path.Combine(INSTALL_DIR, "shared", "Microsoft.AspNetCore.App");
-        }
-
         public TestAssemblyResolver(AssemblyLoadContext loadContext, string testAssemblyPath)
         {
             _loadContext = loadContext;
 
+            _windowsDesktopRuntimes = DotNet.GetRuntimes("Microsoft.WindowsDesktop.App");
+            _aspNetCoreRuntimes  = DotNet.GetRuntimes("Microsoft.AspNetCore.App");
+
             InitializeResolutionStrategies(loadContext, testAssemblyPath);
 
             _loadContext.Resolving += OnResolving;
         }
 
         private void InitializeResolutionStrategies(AssemblyLoadContext loadContext, string testAssemblyPath)
         {
-            // First, looking only at direct references by the test assembly, try to determine if
-            // this assembly is using WindowsDesktop (either SWF or WPF) and/or AspNetCore.
+            // Decide whether to try WindowsDeskTop and/or AspNetCore runtimes before any others.
+            // We base this on direct references only, so we will eventually try each of them
+            // later in case there are any indirect references.
             AssemblyDefinition assemblyDef = AssemblyDefinition.ReadAssembly(testAssemblyPath);
-            bool isWindowsDesktop = false;
-            bool isAspNetCore = false;
+            bool tryWindowsDesktopFirst = false;
+            bool tryAspNetCoreFirst = false;
             foreach (var reference in assemblyDef.MainModule.GetTypeReferences())
             {
                 string fn = reference.FullName;
                 if (fn.StartsWith("System.Windows.") || fn.StartsWith("PresentationFramework"))
-                    isWindowsDesktop = true;
+                    tryWindowsDesktopFirst = true;
                 if (fn.StartsWith("Microsoft.AspNetCore."))
-                    isAspNetCore = true;
+                    tryAspNetCoreFirst = true;
             }
 
             // Initialize the list of ResolutionStrategies in the best order depending on
             // what we learned.
             ResolutionStrategies = new List<ResolutionStrategy>();
             
-            if (isWindowsDesktop && Directory.Exists(WINDOWS_DESKTOP_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(WINDOWS_DESKTOP_DIR));
-            if (isAspNetCore && Directory.Exists(ASP_NET_CORE_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(ASP_NET_CORE_DIR));
+            if (tryWindowsDesktopFirst)
+                ResolutionStrategies.Add(new WindowsDesktopStrategy());
+            if (tryAspNetCoreFirst)
+                ResolutionStrategies.Add(new AspNetCoreStrategy());
+
             ResolutionStrategies.Add(new TrustedPlatformAssembliesStrategy());
             ResolutionStrategies.Add(new RuntimeLibrariesStrategy(loadContext, testAssemblyPath));
-            if (!isWindowsDesktop && Directory.Exists(WINDOWS_DESKTOP_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(WINDOWS_DESKTOP_DIR));
-            if (!isAspNetCore && Directory.Exists(ASP_NET_CORE_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(ASP_NET_CORE_DIR));
+
+            if (!tryWindowsDesktopFirst)
+                ResolutionStrategies.Add(new WindowsDesktopStrategy());
+            if (!tryAspNetCoreFirst)
+                ResolutionStrategies.Add(new AspNetCoreStrategy());
         }
 
         public void Dispose()
@@ -201,49 +200,60 @@ public override bool TryToResolve(
             }
         }
 
-        public class AdditionalDirectoryStrategy : ResolutionStrategy
+        public class AdditionalRuntimesStrategy : ResolutionStrategy
         {
-            private string _frameworkDirectory;
+            private IEnumerable<DotNet.RuntimeInfo> _additionalRuntimes;
 
-            public AdditionalDirectoryStrategy(string frameworkDirectory)
+            public AdditionalRuntimesStrategy(string runtimeName)
             {
-                _frameworkDirectory = frameworkDirectory;
+                _additionalRuntimes = DotNet.GetRuntimes(runtimeName);
             }
 
-            public override bool TryToResolve(
-                AssemblyLoadContext loadContext, AssemblyName assemblyName, out Assembly loadedAssembly)
+            public override bool TryToResolve(AssemblyLoadContext loadContext, AssemblyName assemblyName, out Assembly loadedAssembly)
             {
                 loadedAssembly = null;
-                if (assemblyName.Version == null)
+
+                DotNet.RuntimeInfo runtime;
+                if (!FindBestRuntime(assemblyName, out runtime))
                     return false;
 
-                var versionDir = FindBestVersionDir(_frameworkDirectory, assemblyName.Version);
+                string candidate = Path.Combine(runtime.Path, runtime.Version.ToString(), assemblyName.Name + ".dll");
+                if (!File.Exists(candidate))
+                    return false;
 
-                if (versionDir != null)
-                {
-                    string candidate = Path.Combine(_frameworkDirectory, versionDir, assemblyName.Name + ".dll");
-                    if (File.Exists(candidate))
-                    {
-                        loadedAssembly = loadContext.LoadFromAssemblyPath(candidate);
-                        log.Info("'{0}' ({1}) assembly is loaded from AdditionalFrameworkDirectory {2} dependencies with best candidate version {3}",
-                            assemblyName,
-                            loadedAssembly.Location,
-                            _frameworkDirectory,
-                            versionDir);
+                loadedAssembly = loadContext.LoadFromAssemblyPath(candidate);
+                return true;
+            }
 
-                        return true;
-                    }
-                    else
-                    {
-                        log.Debug("Best version dir for {0} is {1}, but there is no {2} file", _frameworkDirectory, versionDir, candidate);
-                        return false;
-                    }
+            private bool FindBestRuntime(AssemblyName assemblyName, out DotNet.RuntimeInfo bestRuntime)
+            {
+                bestRuntime = null;
+                var targetVersion = assemblyName.Version;
+
+                if (targetVersion is null)
+                    return false;
+
+                foreach (var candidate in _additionalRuntimes)
+                {
+                    if (candidate.Version >= targetVersion)
+                        if (bestRuntime is null || bestRuntime.Version > candidate.Version)
+                            bestRuntime = candidate;
                 }
 
-                return false;
+                return bestRuntime is not null;
             }
         }
 
+        public class WindowsDesktopStrategy : AdditionalRuntimesStrategy
+        {
+            public WindowsDesktopStrategy() : base("Microsoft.WindowsDesktop.App") { }
+        }
+
+        public class AspNetCoreStrategy : AdditionalRuntimesStrategy
+        {
+            public AspNetCoreStrategy() : base("Microsoft.AspNetCore.App") { }
+        }
+
         #endregion
 
         #region HelperMethods
diff --git a/src/NUnitEngine/nunit.engine/Services/AgentProcess.cs b/src/NUnitEngine/nunit.engine/Services/AgentProcess.cs
@@ -73,7 +73,7 @@ public AgentProcess(TestAgency agency, TestPackage package, Guid agentId)
                     if (Path.DirectorySeparatorChar != '\\')
                         throw new Exception("Running .NET Core as X86 is currently only supported on Windows");
 
-                    var x86_dotnet_exe = Path.Combine(DotNet.GetX86InstallDirectory(), "dotnet.exe");
+                    var x86_dotnet_exe = Path.Combine(DotNet.X86InstallDirectory, "dotnet.exe");
                     if (!File.Exists(x86_dotnet_exe))
                         throw new Exception("The X86 version of dotnet.exe is not installed");
 
diff --git a/src/NUnitEngine/nunit.engine/Services/RuntimeLocators/NetCoreRuntimeLocator.cs b/src/NUnitEngine/nunit.engine/Services/RuntimeLocators/NetCoreRuntimeLocator.cs
