Find correct x64 host on arm64 machines

src/clickonce/launcher/HostFinder.cs

@@ -8,12 +8,15 @@
 
 namespace Microsoft.Deployment.Launcher
 {
-    internal static class HostFinder
+    internal class HostFinder
     {
+        private readonly string applicationFilePath;
+        private string arch;
+
         /// <summary>
         /// Gets full path to .NET host appropriate for activating the application.
         /// 
-        /// .NET host'slocation can be obtained from multiple locations.
+        /// .NET host's location can be obtained from multiple locations.
         ///
         /// Current code searches in default, global shared runtime, location only:
         /// %ProgramFiles%\dotnet and %ProgramFiles(x86)%\dotnet
@@ -28,10 +31,48 @@ internal static class HostFinder
         /// 3) Global location
         /// </summary>
         /// <param name="applicationFilePath">Full path to application</param>
-        /// <returns></returns>
+        /// <returns>Path to host</returns>
         internal static string GetHost(string applicationFilePath)
         {
-            string arch = GetProcessorArchitectureFromAssembly(applicationFilePath);
+            HostFinder hf = new HostFinder(applicationFilePath);
+            return hf.GetHost();
+        }
+
+        /// <summary>
+        /// Checks if running on Arm64 system
+        /// </summary>
+        private bool IsArm64System
+        {
+            get
+            {
+                string proc = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
+                if (!string.IsNullOrEmpty(proc) && proc.ToLower() == "arm64")
+                {
+                    return true;
+                }
+
+                proc = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432");
+                if (!string.IsNullOrEmpty(proc) && proc.ToLower() == "arm64")
+                {
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        private HostFinder(string path)
+        {
+            applicationFilePath = path;
+        }
+
+        /// <summary>
+        /// Gets full path to .NET host appropriate for activating the application.
+        /// </summary>
+        /// <returns>Path to host</returns>
+        private string GetHost()
+        {
+            arch = GetProcessorArchitectureFromAssembly(applicationFilePath);
 
             if (arch == "x86")
             {
@@ -55,7 +96,7 @@ internal static string GetHost(string applicationFilePath)
         /// </summary>
         /// <param name="is64bit">If 64-bit bitness is required</param>
         /// <returns></returns>
-        private static string GetProgramFilesFolder(bool is64bit = false)
+        private string GetProgramFilesFolder(bool is64bit = false)
         {
             return is64bit ?
                 (Environment.Is64BitProcess ?
@@ -69,18 +110,26 @@ private static string GetProgramFilesFolder(bool is64bit = false)
         /// </summary>
         /// <param name="is64bit">If 64-bit bitness is required</param>
         /// <returns></returns>
-        private static string GetGlobalHost(bool is64bit = false)
+        private string GetGlobalHost(bool is64bit = false)
         {
             string folder = GetProgramFilesFolder(is64bit);
-            string host = !string.IsNullOrEmpty(folder) ? Path.Combine(folder, "dotnet\\dotnet.exe") : string.Empty;
+            string relativeHostPath = "dotnet\\dotnet.exe";
+
+            // On Arm64 systems, x64 host is in "x64" sub-folder
+            if (is64bit && arch == "amd64" && IsArm64System)
+            {
+                relativeHostPath = "dotnet\\x64\\dotnet.exe";
+            }
+
+            string host = !string.IsNullOrEmpty(folder) ? Path.Combine(folder, relativeHostPath) : string.Empty;
             return File.Exists(host) ? host : string.Empty;
         }
 
         /// <summary>
         /// Gets full path to x86 .NET host.
         /// </summary>
         /// <returns>X86 host</returns>
-        private static string GetX86Host()
+        private string GetX86Host()
         {
             return GetGlobalHost();
         }
@@ -89,7 +138,7 @@ private static string GetX86Host()
         /// Gets full path to 64-bit .NET host.
         /// </summary>
         /// <returns>64-bit host</returns>
-        private static string Get64bitHost()
+        private string Get64bitHost()
         {
             return Environment.Is64BitOperatingSystem ? GetGlobalHost(true) : string.Empty;
         }
@@ -99,7 +148,7 @@ private static string Get64bitHost()
         /// </summary>
         /// <param name="path">Assembly path</param>
         /// <returns></returns>
-        private static string GetProcessorArchitectureFromAssembly(string path)
+        private string GetProcessorArchitectureFromAssembly(string path)
         {
             string processorArchitecture = string.Empty;
 
@@ -124,7 +173,7 @@ private static string GetProcessorArchitectureFromAssembly(string path)
                         processorArchitecture.ToLowerInvariant();
         }
 
-        private static Guid GetGuidOfType(Type type)
+        private Guid GetGuidOfType(Type type)
         {
             var guidAttr = (GuidAttribute)Attribute.GetCustomAttribute(type, typeof(GuidAttribute), false);
             return new Guid(guidAttr.Value);