Modernize DotNetSdkLocationHelper and hostfxr interop. (#339)

teo-tsirpanis · web-flow · commit 6bbaaa5f1919 · 2025-09-30T13:02:45.000+02:00
* Use framework API to resolve symlink.

* Refactor hostfxr bindings and use the P/Invoke source generator.

* Use newer APIs in `DotNetSdkLocationHelper`.

* Use custom marshaller for auto-encoding strings.

* Remove BOM.

* Remove assertions inside native callbacks.

* Some more cleanups.
diff --git a/src/MSBuildLocator/DotNetSdkLocationHelper.cs b/src/MSBuildLocator/DotNetSdkLocationHelper.cs
@@ -17,12 +17,13 @@
 
 namespace Microsoft.Build.Locator
 {
-    internal static class DotNetSdkLocationHelper
+    internal static partial class DotNetSdkLocationHelper
     {
-        private static readonly Regex VersionRegex = new Regex(@"^(\d+)\.(\d+)\.(\d+)", RegexOptions.Multiline);
-        private static readonly bool IsWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-        private static readonly string ExeName = IsWindows ? "dotnet.exe" : "dotnet";
-        private static readonly Lazy<IList<string>> s_dotnetPathCandidates = new(() => ResolveDotnetPathCandidates());
+        [GeneratedRegex(@"^(\d+)\.(\d+)\.(\d+)", RegexOptions.Multiline)]
+        private static partial Regex VersionRegex();
+
+        private static string ExeName => OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet";
+        private static readonly Lazy<List<string>> s_dotnetPathCandidates = new(() => ResolveDotnetPathCandidates());
 
         public static VisualStudioInstance? GetInstance(string dotNetSdkPath, bool allowQueryAllRuntimeVersions)
         {
@@ -38,7 +39,7 @@ internal static class DotNetSdkLocationHelper
             }
 
             // Preview versions contain a hyphen after the numeric part of the version. Version.TryParse doesn't accept that.
-            Match versionMatch = VersionRegex.Match(File.ReadAllText(versionPath));
+            Match versionMatch = VersionRegex().Match(File.ReadAllText(versionPath));
 
             if (!versionMatch.Success)
             {
@@ -116,10 +117,9 @@ public static IEnumerable<VisualStudioInstance> GetInstances(string workingDirec
             static IEnumerable<string> GetAllAvailableSDKs(bool allowAllDotnetLocations)
             {
                 bool foundSdks = false;
-                string[]? resolvedPaths = null;
                 foreach (string dotnetPath in s_dotnetPathCandidates.Value)
                 {
-                    int rc = NativeMethods.hostfxr_get_available_sdks(exe_dir: dotnetPath, result: (key, value) => resolvedPaths = value);
+                    int rc = NativeMethods.hostfxr_get_available_sdks(exe_dir: dotnetPath, out string[]? resolvedPaths);
 
                     if (rc == 0 && resolvedPaths != null)
                     {
@@ -150,13 +150,7 @@ static IEnumerable<string> GetAllAvailableSDKs(bool allowAllDotnetLocations)
                 string? resolvedSdk = null;
                 foreach (string dotnetPath in s_dotnetPathCandidates.Value)
                 {
-                    int rc = NativeMethods.hostfxr_resolve_sdk2(exe_dir: dotnetPath, working_dir: workingDirectory, flags: 0, result: (key, value) =>
-                    {
-                        if (key == NativeMethods.hostfxr_resolve_sdk2_result_key_t.resolved_sdk_dir)
-                        {
-                            resolvedSdk = value;
-                        }
-                    });
+                    int rc = NativeMethods.hostfxr_resolve_sdk2(exe_dir: dotnetPath, working_dir: workingDirectory, flags: 0, out resolvedSdk, out _);
 
                     if (rc == 0)
                     {
@@ -178,7 +172,7 @@ static IEnumerable<string> GetAllAvailableSDKs(bool allowAllDotnetLocations)
         private static void ModifyUnmanagedDllResolver(Action<AssemblyLoadContext> resolverAction)
         {
             // For Windows hostfxr is loaded in the process.
-            if (!IsWindows)
+            if (!OperatingSystem.IsWindows())
             {
                 var loadContext = AssemblyLoadContext.GetLoadContext(Assembly.GetExecutingAssembly());
                 if (loadContext != null)
@@ -197,9 +191,9 @@ private static IntPtr HostFxrResolver(Assembly assembly, string libraryName)
             }
 
             string hostFxrLibName =
-                RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
+                OperatingSystem.IsWindows() ?
                 "hostfxr.dll" :
-                RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "libhostfxr.dylib" : "libhostfxr.so";
+                OperatingSystem.IsMacOS() ? "libhostfxr.dylib" : "libhostfxr.so";
             string hostFxrRoot = string.Empty;
 
             // Get the dotnet path candidates
@@ -237,12 +231,12 @@ private static IntPtr HostFxrResolver(Assembly assembly, string libraryName)
 
         private static string SdkResolutionExceptionMessage(string methodName) => $"Failed to find all versions of .NET Core MSBuild. Call to {methodName}. There may be more details in stderr.";
 
-        private static IList<string> ResolveDotnetPathCandidates()
+        private static List<string> ResolveDotnetPathCandidates()
         {
             var pathCandidates = new List<string>();
             AddIfValid(GetDotnetPathFromROOT());
 
-            string? dotnetExePath = GetCurrentProcessPath();
+            string? dotnetExePath = Environment.ProcessPath;
             bool isRunFromDotnetExecutable = !string.IsNullOrEmpty(dotnetExePath)
                 && Path.GetFileName(dotnetExePath).Equals(ExeName, StringComparison.InvariantCultureIgnoreCase);
 
@@ -254,9 +248,9 @@ private static IList<string> ResolveDotnetPathCandidates()
             string? hostPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");
             if (!string.IsNullOrEmpty(hostPath) && File.Exists(hostPath))
             {
-                if (!IsWindows)
+                if (!OperatingSystem.IsWindows())
                 {
-                    hostPath = realpath(hostPath) ?? hostPath;
+                    hostPath = File.ResolveLinkTarget(hostPath, true)?.FullName ?? hostPath;
                 }
 
                 AddIfValid(Path.GetDirectoryName(hostPath));
@@ -289,8 +283,6 @@ void AddIfValid(string? path)
             return dotnetPath;
         }
 
-        private static string? GetCurrentProcessPath() => Environment.ProcessPath;
-
         private static string? GetDotnetPathFromPATH()
         {
             string? dotnetPath = null;
@@ -314,19 +306,6 @@ void AddIfValid(string? path)
             return dotnetPath;
         }
 
-        /// <summary>
-        /// This native method call determines the actual location of path, including
-        /// resolving symbolic links.
-        /// </summary>
-        private static string? realpath(string path)
-        {
-            IntPtr ptr = NativeMethods.realpath(path, IntPtr.Zero);
-            string? result = Marshal.PtrToStringAuto(ptr);
-            NativeMethods.free(ptr);
-
-            return result;
-        }
-
         private static string? FindDotnetPathFromEnvVariable(string environmentVariable)
         {
             string? dotnetPath = Environment.GetEnvironmentVariable(environmentVariable);
@@ -347,9 +326,9 @@ private static void SetEnvironmentVariableIfEmpty(string name, string value)
             string fullPathToDotnetFromRoot = Path.Combine(dotnetPath, ExeName);
             if (File.Exists(fullPathToDotnetFromRoot))
             {
-                if (!IsWindows)
+                if (!OperatingSystem.IsWindows())
                 {
-                    fullPathToDotnetFromRoot = realpath(fullPathToDotnetFromRoot) ?? fullPathToDotnetFromRoot;
+                    fullPathToDotnetFromRoot = File.ResolveLinkTarget(fullPathToDotnetFromRoot, true)?.FullName ?? fullPathToDotnetFromRoot;
                     return File.Exists(fullPathToDotnetFromRoot) ? Path.GetDirectoryName(fullPathToDotnetFromRoot) : null;
                 }
 
diff --git a/src/MSBuildLocator/Microsoft.Build.Locator.csproj b/src/MSBuildLocator/Microsoft.Build.Locator.csproj
@@ -14,6 +14,7 @@
     <PackageTags>msbuildlocator;locator;buildlocator</PackageTags>
     <EnablePackageValidation>true</EnablePackageValidation>
     <PackageValidationBaselineVersion>1.6.1</PackageValidationBaselineVersion>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition="'$(TargetFramework)'=='net46'">
     <DefineConstants>$(DefineConstants);FEATURE_VISUALSTUDIOSETUP</DefineConstants>
diff --git a/src/MSBuildLocator/NativeMethods.cs b/src/MSBuildLocator/NativeMethods.cs
@@ -1,12 +1,16 @@
 ﻿// Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+#if NETCOREAPP
 using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
 
 namespace Microsoft.Build.Locator
 {
-    internal class NativeMethods
+    internal partial class NativeMethods
     {
         internal const string HostFxrName = "hostfxr";
 
@@ -15,37 +19,104 @@ internal enum hostfxr_resolve_sdk2_flags_t
             disallow_prerelease = 0x1,
         };
 
-        internal enum hostfxr_resolve_sdk2_result_key_t
+        private enum hostfxr_resolve_sdk2_result_key_t
         {
             resolved_sdk_dir = 0,
             global_json_path = 1,
         };
 
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
-        internal delegate void hostfxr_resolve_sdk2_result_fn(
-                hostfxr_resolve_sdk2_result_key_t key,
-                string value);
-
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
-        internal delegate void hostfxr_get_available_sdks_result_fn(
-                int sdk_count,
-                [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)]
-                string[] value);
+        internal static int hostfxr_resolve_sdk2(string exe_dir, string working_dir, hostfxr_resolve_sdk2_flags_t flags, out string resolved_sdk_dir, out string global_json_path)
+        {
+            Debug.Assert(t_resolve_sdk2_resolved_sdk_dir is null);
+            Debug.Assert(t_resolve_sdk2_global_json_path is null);
+            try
+            {
+                unsafe
+                {
+                    int result = hostfxr_resolve_sdk2(exe_dir, working_dir, flags, &hostfxr_resolve_sdk2_callback);
+                    resolved_sdk_dir = t_resolve_sdk2_resolved_sdk_dir;
+                    global_json_path = t_resolve_sdk2_global_json_path;
+                    return result;
+                }
+            }
+            finally
+            {
+                t_resolve_sdk2_resolved_sdk_dir = null;
+                t_resolve_sdk2_global_json_path = null;
+            }
+        }
 
-        [DllImport(HostFxrName, CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int hostfxr_resolve_sdk2(
+        [LibraryImport(HostFxrName, StringMarshallingCustomType = typeof(AutoStringMarshaller))]
+        [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+        private static unsafe partial int hostfxr_resolve_sdk2(
             string exe_dir,
             string working_dir,
             hostfxr_resolve_sdk2_flags_t flags,
-            hostfxr_resolve_sdk2_result_fn result);
+            delegate* unmanaged[Cdecl]<hostfxr_resolve_sdk2_result_key_t, void*, void> result);
+
+        [ThreadStatic]
+        private static string t_resolve_sdk2_resolved_sdk_dir, t_resolve_sdk2_global_json_path;
+
+        [UnmanagedCallersOnly(CallConvs = [typeof(CallConvCdecl)])]
+        private static unsafe void hostfxr_resolve_sdk2_callback(hostfxr_resolve_sdk2_result_key_t key, void* value)
+        {
+            string str = AutoStringMarshaller.ConvertToManaged(value);
+            switch (key)
+            {
+                case hostfxr_resolve_sdk2_result_key_t.resolved_sdk_dir:
+                    t_resolve_sdk2_resolved_sdk_dir = str;
+                    break;
+                case hostfxr_resolve_sdk2_result_key_t.global_json_path:
+                    t_resolve_sdk2_global_json_path = str;
+                    break;
+            }
+        }
+
+        internal static int hostfxr_get_available_sdks(string exe_dir, out string[] sdks)
+        {
+            Debug.Assert(t_get_available_sdks_result is null);
+            try
+            {
+                unsafe
+                {
+                    int result = hostfxr_get_available_sdks(exe_dir, &hostfxr_get_available_sdks_callback);
+                    sdks = t_get_available_sdks_result;
+                    return result;
+                }
+            }
+            finally
+            {
+                t_get_available_sdks_result = null;
+            }
+        }
+
+        [LibraryImport(HostFxrName, StringMarshallingCustomType = typeof(AutoStringMarshaller))]
+        [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+        private static unsafe partial int hostfxr_get_available_sdks(string exe_dir, delegate* unmanaged[Cdecl]<int, void**, void> result);
+
+        [ThreadStatic]
+        private static string[] t_get_available_sdks_result;
 
-        [DllImport(HostFxrName, CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int hostfxr_get_available_sdks(string exe_dir, hostfxr_get_available_sdks_result_fn result);
+        [UnmanagedCallersOnly(CallConvs = [typeof(CallConvCdecl)])]
+        private static unsafe void hostfxr_get_available_sdks_callback(int count, void** sdks)
+        {
+            string[] result = new string[count];
+            for (int i = 0; i < count; i++)
+            {
+                result[i] = AutoStringMarshaller.ConvertToManaged(sdks[i]);
+            }
+            t_get_available_sdks_result = result;
+        }
+
+        [CustomMarshaller(typeof(string), MarshalMode.Default, typeof(AutoStringMarshaller))]
+        internal static unsafe class AutoStringMarshaller
+        {
+            public static void* ConvertToUnmanaged(string s) => (void*)Marshal.StringToCoTaskMemAuto(s);
 
-        [DllImport("libc", ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern IntPtr realpath(string path, IntPtr buffer);
+            public static void Free(void* ptr) => Marshal.FreeCoTaskMem((nint)ptr);
 
-        [DllImport("libc", ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void free(IntPtr ptr);
+            public static string ConvertToManaged(void* ptr) => Marshal.PtrToStringAuto((nint)ptr);
+        }
     }
 }
+#endif

Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,13 @@`
`17`	`17`
`18`	`18`	`namespace Microsoft.Build.Locator`
`19`	`19`	`{`
`20`		`- internal static class DotNetSdkLocationHelper`
	`20`	`+ internal static partial class DotNetSdkLocationHelper`
`21`	`21`	`{`
`22`		`- private static readonly Regex VersionRegex = new Regex(@"^(\d+)\.(\d+)\.(\d+)", RegexOptions.Multiline);`
`23`		`- private static readonly bool IsWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);`
`24`		`- private static readonly string ExeName = IsWindows ? "dotnet.exe" : "dotnet";`
`25`		`- private static readonly Lazy<IList<string>> s_dotnetPathCandidates = new(() => ResolveDotnetPathCandidates());`
	`22`	`+ [GeneratedRegex(@"^(\d+)\.(\d+)\.(\d+)", RegexOptions.Multiline)]`
	`23`	`+ private static partial Regex VersionRegex();`
	`24`	`+`
	`25`	`+ private static string ExeName => OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet";`
	`26`	`+ private static readonly Lazy<List<string>> s_dotnetPathCandidates = new(() => ResolveDotnetPathCandidates());`
`26`	`27`
`27`	`28`	`public static VisualStudioInstance? GetInstance(string dotNetSdkPath, bool allowQueryAllRuntimeVersions)`
`28`	`29`	`{`
`@@ -38,7 +39,7 @@ internal static class DotNetSdkLocationHelper`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`// Preview versions contain a hyphen after the numeric part of the version. Version.TryParse doesn't accept that.`
`41`		`- Match versionMatch = VersionRegex.Match(File.ReadAllText(versionPath));`
	`42`	`+ Match versionMatch = VersionRegex().Match(File.ReadAllText(versionPath));`
`42`	`43`
`43`	`44`	`if (!versionMatch.Success)`
`44`	`45`	`{`
`@@ -116,10 +117,9 @@ public static IEnumerable<VisualStudioInstance> GetInstances(string workingDirec`
`116`	`117`	`static IEnumerable<string> GetAllAvailableSDKs(bool allowAllDotnetLocations)`
`117`	`118`	`{`
`118`	`119`	`bool foundSdks = false;`
`119`		`- string[]? resolvedPaths = null;`
`120`	`120`	`foreach (string dotnetPath in s_dotnetPathCandidates.Value)`
`121`	`121`	`{`
`122`		`- int rc = NativeMethods.hostfxr_get_available_sdks(exe_dir: dotnetPath, result: (key, value) => resolvedPaths = value);`
	`122`	`+ int rc = NativeMethods.hostfxr_get_available_sdks(exe_dir: dotnetPath, out string[]? resolvedPaths);`
`123`	`123`
`124`	`124`	`if (rc == 0 && resolvedPaths != null)`
`125`	`125`	`{`
`@@ -150,13 +150,7 @@ static IEnumerable<string> GetAllAvailableSDKs(bool allowAllDotnetLocations)`
`150`	`150`	`string? resolvedSdk = null;`
`151`	`151`	`foreach (string dotnetPath in s_dotnetPathCandidates.Value)`
`152`	`152`	`{`
`153`		`- int rc = NativeMethods.hostfxr_resolve_sdk2(exe_dir: dotnetPath, working_dir: workingDirectory, flags: 0, result: (key, value) =>`
`154`		`- {`
`155`		`- if (key == NativeMethods.hostfxr_resolve_sdk2_result_key_t.resolved_sdk_dir)`
`156`		`- {`
`157`		`- resolvedSdk = value;`
`158`		`- }`
`159`		`- });`
	`153`	`+ int rc = NativeMethods.hostfxr_resolve_sdk2(exe_dir: dotnetPath, working_dir: workingDirectory, flags: 0, out resolvedSdk, out _);`
`160`	`154`
`161`	`155`	`if (rc == 0)`
`162`	`156`	`{`
`@@ -178,7 +172,7 @@ static IEnumerable<string> GetAllAvailableSDKs(bool allowAllDotnetLocations)`
`178`	`172`	`private static void ModifyUnmanagedDllResolver(Action<AssemblyLoadContext> resolverAction)`
`179`	`173`	`{`
`180`	`174`	`// For Windows hostfxr is loaded in the process.`
`181`		`- if (!IsWindows)`
	`175`	`+ if (!OperatingSystem.IsWindows())`
`182`	`176`	`{`
`183`	`177`	`var loadContext = AssemblyLoadContext.GetLoadContext(Assembly.GetExecutingAssembly());`
`184`	`178`	`if (loadContext != null)`
`@@ -197,9 +191,9 @@ private static IntPtr HostFxrResolver(Assembly assembly, string libraryName)`
`197`	`191`	`}`
`198`	`192`
`199`	`193`	`string hostFxrLibName =`
`200`		`- RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?`
	`194`	`+ OperatingSystem.IsWindows() ?`
`201`	`195`	`"hostfxr.dll" :`
`202`		`- RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "libhostfxr.dylib" : "libhostfxr.so";`
	`196`	`+ OperatingSystem.IsMacOS() ? "libhostfxr.dylib" : "libhostfxr.so";`
`203`	`197`	`string hostFxrRoot = string.Empty;`
`204`	`198`
`205`	`199`	`// Get the dotnet path candidates`
`@@ -237,12 +231,12 @@ private static IntPtr HostFxrResolver(Assembly assembly, string libraryName)`
`237`	`231`
`238`	`232`	`private static string SdkResolutionExceptionMessage(string methodName) => $"Failed to find all versions of .NET Core MSBuild. Call to {methodName}. There may be more details in stderr.";`
`239`	`233`
`240`		`- private static IList<string> ResolveDotnetPathCandidates()`
	`234`	`+ private static List<string> ResolveDotnetPathCandidates()`
`241`	`235`	`{`
`242`	`236`	`var pathCandidates = new List<string>();`
`243`	`237`	`AddIfValid(GetDotnetPathFromROOT());`
`244`	`238`
`245`		`- string? dotnetExePath = GetCurrentProcessPath();`
	`239`	`+ string? dotnetExePath = Environment.ProcessPath;`
`246`	`240`	`bool isRunFromDotnetExecutable = !string.IsNullOrEmpty(dotnetExePath)`
`247`	`241`	`&& Path.GetFileName(dotnetExePath).Equals(ExeName, StringComparison.InvariantCultureIgnoreCase);`
`248`	`242`
`@@ -254,9 +248,9 @@ private static IList<string> ResolveDotnetPathCandidates()`
`254`	`248`	`string? hostPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");`
`255`	`249`	`if (!string.IsNullOrEmpty(hostPath) && File.Exists(hostPath))`
`256`	`250`	`{`
`257`		`- if (!IsWindows)`
	`251`	`+ if (!OperatingSystem.IsWindows())`
`258`	`252`	`{`
`259`		`- hostPath = realpath(hostPath) ?? hostPath;`
	`253`	`+ hostPath = File.ResolveLinkTarget(hostPath, true)?.FullName ?? hostPath;`
`260`	`254`	`}`
`261`	`255`
`262`	`256`	`AddIfValid(Path.GetDirectoryName(hostPath));`
`@@ -289,8 +283,6 @@ void AddIfValid(string? path)`
`289`	`283`	`return dotnetPath;`
`290`	`284`	`}`
`291`	`285`
`292`		`- private static string? GetCurrentProcessPath() => Environment.ProcessPath;`
`293`		`-`
`294`	`286`	`private static string? GetDotnetPathFromPATH()`
`295`	`287`	`{`
`296`	`288`	`string? dotnetPath = null;`
`@@ -314,19 +306,6 @@ void AddIfValid(string? path)`
`314`	`306`	`return dotnetPath;`
`315`	`307`	`}`
`316`	`308`
`317`		`- /// <summary>`
`318`		`- /// This native method call determines the actual location of path, including`
`319`		`- /// resolving symbolic links.`
`320`		`- /// </summary>`
`321`		`- private static string? realpath(string path)`
`322`		`- {`
`323`		`- IntPtr ptr = NativeMethods.realpath(path, IntPtr.Zero);`
`324`		`- string? result = Marshal.PtrToStringAuto(ptr);`
`325`		`- NativeMethods.free(ptr);`
`326`		`-`
`327`		`- return result;`
`328`		`- }`
`329`		`-`
`330`	`309`	`private static string? FindDotnetPathFromEnvVariable(string environmentVariable)`
`331`	`310`	`{`
`332`	`311`	`string? dotnetPath = Environment.GetEnvironmentVariable(environmentVariable);`
`@@ -347,9 +326,9 @@ private static void SetEnvironmentVariableIfEmpty(string name, string value)`
`347`	`326`	`string fullPathToDotnetFromRoot = Path.Combine(dotnetPath, ExeName);`
`348`	`327`	`if (File.Exists(fullPathToDotnetFromRoot))`
`349`	`328`	`{`
`350`		`- if (!IsWindows)`
	`329`	`+ if (!OperatingSystem.IsWindows())`
`351`	`330`	`{`
`352`		`- fullPathToDotnetFromRoot = realpath(fullPathToDotnetFromRoot) ?? fullPathToDotnetFromRoot;`
	`331`	`+ fullPathToDotnetFromRoot = File.ResolveLinkTarget(fullPathToDotnetFromRoot, true)?.FullName ?? fullPathToDotnetFromRoot;`
`353`	`332`	`return File.Exists(fullPathToDotnetFromRoot) ? Path.GetDirectoryName(fullPathToDotnetFromRoot) : null;`
`354`	`333`	`}`
`355`	`334`