Locate usable MSBuild when launching .NET Core BuildHost

JoeRobich · JoeRobich · commit bccc578e6f63 · 2025-07-21T08:05:35.000-07:00
diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
@@ -53,7 +53,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageVersion Include="Microsoft.Build.Locator" Version="1.6.10" />
+    <PackageVersion Include="Microsoft.Build.Locator" Version="1.8.1" />
 
     <!--
       Visual Studio
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsProjectSystem.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsProjectSystem.cs
@@ -158,7 +158,7 @@ public async ValueTask TryRemoveMiscellaneousDocumentAsync(DocumentUri uri, bool
         var isFileBasedProgram = VirtualProjectXmlProvider.IsFileBasedProgram(documentPath, textAndVersion.Text);
 
         const BuildHostProcessKind buildHostKind = BuildHostProcessKind.NetCore;
-        var buildHost = await buildHostProcessManager.GetBuildHostAsync(buildHostKind, cancellationToken);
+        var buildHost = await buildHostProcessManager.GetBuildHostAsync(buildHostKind, virtualProjectPath, dotnetPath: null, cancellationToken);
         var loadedFile = await buildHost.LoadProjectAsync(virtualProjectPath, virtualProjectContent, languageName: LanguageNames.CSharp, cancellationToken);
 
         return new RemoteProjectLoadResult(
diff --git a/src/Workspaces/MSBuild/BuildHost/BuildHost.cs b/src/Workspaces/MSBuild/BuildHost/BuildHost.cs
@@ -23,6 +23,7 @@ internal sealed class BuildHost : IBuildHost
     private readonly RpcServer _server;
     private readonly object _gate = new object();
     private ProjectBuildManager? _buildManager;
+    private MSBuildLocation? _msBuildLocation;
 
     public BuildHost(BuildHostLogger logger, ImmutableDictionary<string, string> globalMSBuildProperties, string? binaryLogPath, RpcServer server)
     {
@@ -32,14 +33,14 @@ public BuildHost(BuildHostLogger logger, ImmutableDictionary<string, string> glo
         _server = server;
     }
 
-    private bool TryEnsureMSBuildLoaded(string projectOrSolutionFilePath)
+    public MSBuildLocation? FindUsableMSBuild(string projectOrSolutionFilePath)
     {
         lock (_gate)
         {
             // If we've already created our MSBuild types, then there's nothing further to do.
             if (MSBuildLocator.IsRegistered)
             {
-                return true;
+                return _msBuildLocation;
             }
 
             if (!PlatformInformation.IsRunningOnMono)
@@ -59,14 +60,15 @@ private bool TryEnsureMSBuildLoaded(string projectOrSolutionFilePath)
 
                 // Locate the right SDK for this particular project; MSBuildLocator ensures in this case the first one is the preferred one.
                 // TODO: we should pick the appropriate instance back in the main process and just use the one chosen here.
-                var options = new VisualStudioInstanceQueryOptions { DiscoveryTypes = DiscoveryType.DotNetSdk, WorkingDirectory = Path.GetDirectoryName(projectOrSolutionFilePath) };
+                var options = new VisualStudioInstanceQueryOptions { DiscoveryTypes = DiscoveryType.DotNetSdk, WorkingDirectory = Path.GetDirectoryName(projectOrSolutionFilePath), AllowAllDotnetLocations = true, AllowAllRuntimeVersions = true };
                 instance = MSBuildLocator.QueryVisualStudioInstances(options).FirstOrDefault();
 
 #endif
 
                 if (instance != null)
                 {
                     MSBuildLocator.RegisterInstance(instance);
+                    _msBuildLocation = new(instance.MSBuildPath, instance.Version.ToString());
                     _logger.LogInformation($"Registered MSBuild instance at {instance.MSBuildPath}");
                 }
                 else
@@ -96,7 +98,7 @@ private bool TryEnsureMSBuildLoaded(string projectOrSolutionFilePath)
 #endif
             }
 
-            return MSBuildLocator.IsRegistered;
+            return _msBuildLocation;
         }
     }
 
@@ -122,14 +124,9 @@ private void CreateBuildManager()
         }
     }
 
-    public bool HasUsableMSBuild(string projectOrSolutionFilePath)
-    {
-        return TryEnsureMSBuildLoaded(projectOrSolutionFilePath);
-    }
-
     private void EnsureMSBuildLoaded(string projectFilePath)
     {
-        Contract.ThrowIfFalse(TryEnsureMSBuildLoaded(projectFilePath), $"We don't have an MSBuild to use; {nameof(HasUsableMSBuild)} should have been called first to check.");
+        Contract.ThrowIfNull(FindUsableMSBuild(projectFilePath), $"We don't have an MSBuild to use; {nameof(FindUsableMSBuild)} should have been called first to check.");
     }
 
     /// <summary>
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/IBuildHost.cs b/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/IBuildHost.cs
@@ -12,7 +12,7 @@ namespace Microsoft.CodeAnalysis.MSBuild;
 /// </summary>
 internal interface IBuildHost
 {
-    bool HasUsableMSBuild(string projectOrSolutionFilePath);
+    MSBuildLocation? FindUsableMSBuild(string projectOrSolutionFilePath);
     Task<int> LoadProjectFileAsync(string projectFilePath, string languageName, CancellationToken cancellationToken);
 
     /// <summary>Permits loading a project file which only exists in-memory, for example, for file-based program scenarios.</summary>
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/MSBuildLocation.cs b/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/MSBuildLocation.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.Serialization;
+
+namespace Microsoft.CodeAnalysis.MSBuild;
+
+[DataContract]
+internal sealed class MSBuildLocation(string path, string version)
+{
+    [DataMember(Order = 0)]
+    public string Path { get; } = path;
+
+    [DataMember(Order = 1)]
+    public string Version { get; } = version;
+}
diff --git a/src/Workspaces/MSBuild/Core/MSBuild/BuildHostProcessManager.cs b/src/Workspaces/MSBuild/Core/MSBuild/BuildHostProcessManager.cs
@@ -33,6 +33,8 @@ internal sealed class BuildHostProcessManager : IAsyncDisposable
     private static string MSBuildWorkspaceDirectory => Path.GetDirectoryName(typeof(BuildHostProcessManager).Assembly.Location)!;
     private static bool IsLoadedFromNuGetPackage => File.Exists(Path.Combine(MSBuildWorkspaceDirectory, "..", "..", "microsoft.codeanalysis.workspaces.msbuild.nuspec"));
 
+    private static readonly string DotnetExecutable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet";
+
     public BuildHostProcessManager(ImmutableDictionary<string, string>? globalMSBuildProperties = null, IBinLogPathProvider? binaryLogPathProvider = null, ILoggerFactory? loggerFactory = null)
     {
         _globalMSBuildProperties = globalMSBuildProperties ?? ImmutableDictionary<string, string>.Empty;
@@ -63,58 +65,98 @@ public async Task<RemoteBuildHost> GetBuildHostWithFallbackAsync(string projectF
             buildHostKind = BuildHostProcessKind.NetCore;
         }
 
-        var buildHost = await GetBuildHostAsync(buildHostKind, cancellationToken).ConfigureAwait(false);
+        var buildHost = await GetBuildHostAsync(buildHostKind, projectOrSolutionFilePath, dotnetPath: null, cancellationToken).ConfigureAwait(false);
 
         // If this is a .NET Framework build host, we may not have have build tools installed and thus can't actually use it to build.
         // Check if this is the case. Unlike the mono case, we have to actually ask the other process since MSBuildLocator only allows
         // us to discover VS instances in .NET Framework hosts right now.
         if (buildHostKind == BuildHostProcessKind.NetFramework)
         {
-            if (!await buildHost.HasUsableMSBuildAsync(projectOrSolutionFilePath, cancellationToken).ConfigureAwait(false))
+            var msbuildLocation = await buildHost.FindUsableMSBuildAsync(projectOrSolutionFilePath, cancellationToken).ConfigureAwait(false);
+            if (msbuildLocation is null)
             {
                 // It's not usable, so we'll fall back to the .NET Core one.
                 _logger?.LogWarning($"An installation of Visual Studio or the Build Tools for Visual Studio could not be found; {projectOrSolutionFilePath} will be loaded with the .NET Core SDK and may encounter errors.");
-                return (await GetBuildHostAsync(BuildHostProcessKind.NetCore, cancellationToken).ConfigureAwait(false), actualKind: BuildHostProcessKind.NetCore);
+                return await GetBuildHostWithFallbackAsync(BuildHostProcessKind.NetCore, projectOrSolutionFilePath, cancellationToken).ConfigureAwait(false);
             }
         }
 
         return (buildHost, buildHostKind);
     }
 
-    public async Task<RemoteBuildHost> GetBuildHostAsync(BuildHostProcessKind buildHostKind, CancellationToken cancellationToken)
+    public Task<RemoteBuildHost> GetBuildHostAsync(BuildHostProcessKind buildHostKind, CancellationToken cancellationToken)
+    {
+        return GetBuildHostAsync(buildHostKind, projectOrSolutionFilePath: null, dotnetPath: null, cancellationToken);
+    }
+
+    public async Task<RemoteBuildHost> GetBuildHostAsync(BuildHostProcessKind buildHostKind, string? projectOrSolutionFilePath, string? dotnetPath, CancellationToken cancellationToken)
     {
         using (await _gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
         {
             if (!_processes.TryGetValue(buildHostKind, out var buildHostProcess))
             {
-                var pipeName = Guid.NewGuid().ToString();
-                var processStartInfo = CreateBuildHostStartInfo(buildHostKind, pipeName);
-
-                var process = Process.Start(processStartInfo);
-                Contract.ThrowIfNull(process, "Process.Start failed to launch a process.");
-
-                buildHostProcess = new BuildHostProcess(process, pipeName, _loggerFactory);
-                buildHostProcess.Disconnected += BuildHostProcess_Disconnected;
-
-                // We've subscribed to Disconnected, but if the process crashed before that point we might have not seen it
-                if (process.HasExited)
+                bool reload;
+                do
                 {
-                    buildHostProcess.LogProcessFailure();
-                    throw new Exception($"BuildHost process exited immediately with {process.ExitCode}");
-                }
+                    reload = false;
+
+                    var pipeName = Guid.NewGuid().ToString();
+                    var processStartInfo = CreateBuildHostStartInfo(buildHostKind, pipeName, dotnetPath);
+
+                    var process = Process.Start(processStartInfo);
+                    Contract.ThrowIfNull(process, "Process.Start failed to launch a process.");
+
+                    buildHostProcess = new BuildHostProcess(process, pipeName, _loggerFactory);
+                    buildHostProcess.Disconnected += BuildHostProcess_Disconnected;
+
+                    // We've subscribed to Disconnected, but if the process crashed before that point we might have not seen it
+                    if (process.HasExited)
+                    {
+                        buildHostProcess.LogProcessFailure();
+                        throw new Exception($"BuildHost process exited immediately with {process.ExitCode}");
+                    }
+
+                    // When running on .NET Core, we need to find the right SDK location that can load our project and restart the BuildHost if required.
+                    // When dotnetPath is null, the BuildHost is started with the default dotnet executable, which may not be the right one for the project.
+                    if (buildHostKind == BuildHostProcessKind.NetCore
+                        && projectOrSolutionFilePath is not null
+                        && dotnetPath is null)
+                    {
+                        // The BuildHost will be able to search through all the SDK install locations for a usable MSBuild instance.
+                        var msbuildLocation = await buildHostProcess.BuildHost.FindUsableMSBuildAsync(projectOrSolutionFilePath, cancellationToken).ConfigureAwait(false);
+                        if (msbuildLocation is not null && GetProcessPath() is { } processPath)
+                        {
+                            // The layout of the SDK is such that the dotnet executable is always at the same relative path from the MSBuild location.
+                            dotnetPath = Path.GetFullPath(Path.Combine(msbuildLocation.Path, $"../../{DotnetExecutable}"));
+                            if (dotnetPath is not null && processPath != dotnetPath)
+                            {
+                                // We need to relaunch the .NET BuildHost from a different dotnet instance.
+                                reload = true;
+                                await buildHostProcess.DisposeAsync().ConfigureAwait(false);
+                                _logger?.LogInformation($".NET BuildHost started from {processPath} reloading to start from {dotnetPath} to match necessary SDK location.");
+                            }
+                        }
+                    }
+                } while (reload);
 
                 _processes.Add(buildHostKind, buildHostProcess);
             }
 
             return buildHostProcess.BuildHost;
         }
+
+#if NET
+        static string? GetProcessPath() => Environment.ProcessPath;
+#else
+        static string? GetProcessPath() => Process.GetCurrentProcess().MainModule?.FileName;
+#endif
     }
 
-    internal ProcessStartInfo CreateBuildHostStartInfo(BuildHostProcessKind buildHostKind, string pipeName)
+    internal ProcessStartInfo CreateBuildHostStartInfo(BuildHostProcessKind buildHostKind, string pipeName, string? dotnetPath)
     {
         return buildHostKind switch
         {
-            BuildHostProcessKind.NetCore => CreateDotNetCoreBuildHostStartInfo(pipeName),
+            BuildHostProcessKind.NetCore => CreateDotNetCoreBuildHostStartInfo(pipeName, dotnetPath),
             BuildHostProcessKind.NetFramework => CreateDotNetFrameworkBuildHostStartInfo(pipeName),
             BuildHostProcessKind.Mono => CreateMonoBuildHostStartInfo(pipeName),
             _ => throw ExceptionUtilities.UnexpectedValue(buildHostKind)
@@ -165,11 +207,11 @@ public async ValueTask DisposeAsync()
             await process.DisposeAsync().ConfigureAwait(false);
     }
 
-    private ProcessStartInfo CreateDotNetCoreBuildHostStartInfo(string pipeName)
+    private ProcessStartInfo CreateDotNetCoreBuildHostStartInfo(string pipeName, string? dotnetPath)
     {
         var processStartInfo = new ProcessStartInfo()
         {
-            FileName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet",
+            FileName = dotnetPath ?? DotnetExecutable,
         };
 
         // We need to roll forward to the latest runtime, since the project may be using an SDK (or an SDK required runtime) newer than we ourselves built with.
@@ -231,9 +273,9 @@ private static string GetBuildHostPath(string contentFolderName, string assembly
 
         if (IsLoadedFromNuGetPackage)
         {
-            // When Workspaces.MSBuild is loaded from the NuGet package (as is the case in .NET Interactive, NCrunch, and possibly other use cases) 
+            // When Workspaces.MSBuild is loaded from the NuGet package (as is the case in .NET Interactive, NCrunch, and possibly other use cases)
             // the Build host is deployed under the contentFiles folder.
-            // 
+            //
             // Workspaces.MSBuild.dll Path - .nuget/packages/microsoft.codeanalysis.workspaces.msbuild/{version}/lib/{tfm}/Microsoft.CodeAnalysis.Workspaces.MSBuild.dll
             // MSBuild.BuildHost.dll Path  - .nuget/packages/microsoft.codeanalysis.workspaces.msbuild/{version}/contentFiles/any/any/{contentFolderName}/{assemblyName}
 
diff --git a/src/Workspaces/MSBuild/Core/Rpc/RemoteBuildHost.cs b/src/Workspaces/MSBuild/Core/Rpc/RemoteBuildHost.cs
@@ -19,8 +19,8 @@ public RemoteBuildHost(RpcClient client)
         _client = client;
     }
 
-    public Task<bool> HasUsableMSBuildAsync(string projectOrSolutionFilePath, CancellationToken cancellationToken)
-        => _client.InvokeAsync<bool>(BuildHostTargetObject, nameof(IBuildHost.HasUsableMSBuild), parameters: [projectOrSolutionFilePath], cancellationToken);
+    public Task<MSBuildLocation> FindUsableMSBuildAsync(string projectOrSolutionFilePath, CancellationToken cancellationToken)
+        => _client.InvokeAsync<MSBuildLocation>(BuildHostTargetObject, nameof(IBuildHost.FindUsableMSBuild), parameters: [projectOrSolutionFilePath], cancellationToken);
 
     public async Task<RemoteProjectFile> LoadProjectFileAsync(string projectFilePath, string languageName, CancellationToken cancellationToken)
     {
diff --git a/src/Workspaces/MSBuild/Test/BuildHostProcessManagerTests.cs b/src/Workspaces/MSBuild/Test/BuildHostProcessManagerTests.cs
@@ -18,7 +18,7 @@ public sealed class BuildHostProcessManagerTests
     public void ProcessStartInfo_ForNetCore_RollsForwardToLatestPreview()
     {
         var processStartInfo = new BuildHostProcessManager()
-            .CreateBuildHostStartInfo(BuildHostProcessKind.NetCore, pipeName: "");
+            .CreateBuildHostStartInfo(BuildHostProcessKind.NetCore, pipeName: "", dotnetPath: null);
 
 #if NET
         var rollForwardIndex = processStartInfo.ArgumentList.IndexOf("--roll-forward");
@@ -35,7 +35,7 @@ public void ProcessStartInfo_ForNetCore_RollsForwardToLatestPreview()
     public void ProcessStartInfo_ForNetCore_LaunchesDotNetCLI()
     {
         var processStartInfo = new BuildHostProcessManager()
-            .CreateBuildHostStartInfo(BuildHostProcessKind.NetCore, pipeName: "");
+            .CreateBuildHostStartInfo(BuildHostProcessKind.NetCore, pipeName: "", dotnetPath: null);
 
         Assert.StartsWith("dotnet", processStartInfo.FileName);
     }
@@ -44,7 +44,7 @@ public void ProcessStartInfo_ForNetCore_LaunchesDotNetCLI()
     public void ProcessStartInfo_ForMono_LaunchesMono()
     {
         var processStartInfo = new BuildHostProcessManager()
-            .CreateBuildHostStartInfo(BuildHostProcessKind.Mono, pipeName: "");
+            .CreateBuildHostStartInfo(BuildHostProcessKind.Mono, pipeName: "", dotnetPath: null);
 
         Assert.Equal("mono", processStartInfo.FileName);
     }
@@ -53,7 +53,7 @@ public void ProcessStartInfo_ForMono_LaunchesMono()
     public void ProcessStartInfo_ForNetFramework_LaunchesBuildHost()
     {
         var processStartInfo = new BuildHostProcessManager()
-            .CreateBuildHostStartInfo(BuildHostProcessKind.NetFramework, pipeName: "");
+            .CreateBuildHostStartInfo(BuildHostProcessKind.NetFramework, pipeName: "", dotnetPath: null);
 
         Assert.EndsWith("Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.exe", processStartInfo.FileName);
     }
@@ -70,7 +70,7 @@ internal void ProcessStartInfo_PassesBinLogPath(BuildHostProcessKind buildHostKi
         binLogPathProviderMock.Setup(m => m.GetNewLogPath()).Returns(BinaryLogPath);
 
         var processStartInfo = new BuildHostProcessManager(binaryLogPathProvider: binLogPathProviderMock.Object)
-            .CreateBuildHostStartInfo(buildHostKind, pipeName: "");
+            .CreateBuildHostStartInfo(buildHostKind, pipeName: "", dotnetPath: null);
 
 #if NET
         var binlogIndex = processStartInfo.ArgumentList.IndexOf("--binlog");
@@ -90,7 +90,7 @@ internal void ProcessStartInfo_PassesPipeName(BuildHostProcessKind buildHostKind
         const string PipeName = "TestPipe";
 
         var processStartInfo = new BuildHostProcessManager()
-            .CreateBuildHostStartInfo(buildHostKind, PipeName);
+            .CreateBuildHostStartInfo(buildHostKind, PipeName, dotnetPath: null);
 
 #if NET
         var binlogIndex = processStartInfo.ArgumentList.IndexOf("--pipe");
@@ -111,7 +111,7 @@ internal void ProcessStartInfo_PassesLocale(BuildHostProcessKind buildHostKind)
         const string Locale = "de-DE";
 
         var processStartInfo = new BuildHostProcessManager()
-            .CreateBuildHostStartInfo(buildHostKind, pipeName: "");
+            .CreateBuildHostStartInfo(buildHostKind, pipeName: "", dotnetPath: null);
 
 #if NET
         var localeIndex = processStartInfo.ArgumentList.IndexOf("--locale");
@@ -136,7 +136,7 @@ internal void ProcessStartInfo_PassesProperties(BuildHostProcessKind buildHostKi
 
         var buildHostProcessManager = new BuildHostProcessManager(globalMSBuildProperties);
 
-        var processStartInfo = buildHostProcessManager.CreateBuildHostStartInfo(buildHostKind, pipeName: "");
+        var processStartInfo = buildHostProcessManager.CreateBuildHostStartInfo(buildHostKind, pipeName: "", dotnetPath: null);
 
 #if NET
         foreach (var kvp in globalMSBuildProperties)
diff --git a/src/Workspaces/MSBuild/Test/Utilities/DotNetSdkMSBuildInstalled.cs b/src/Workspaces/MSBuild/Test/Utilities/DotNetSdkMSBuildInstalled.cs
@@ -44,7 +44,7 @@ private static bool HasNetCoreSdkForSolution(string solution)
 
             var buildHost = buildHostProcessManager.GetBuildHostAsync(BuildHostProcessManager.BuildHostProcessKind.NetCore, CancellationToken.None).Result;
 
-            return buildHost.HasUsableMSBuildAsync(solution, CancellationToken.None).Result;
+            return buildHost.FindUsableMSBuildAsync(solution, CancellationToken.None).Result is not null;
         }
         finally
         {
diff --git a/src/Workspaces/MSBuild/Test/Utilities/VisualStudioMSBuildInstalled.cs b/src/Workspaces/MSBuild/Test/Utilities/VisualStudioMSBuildInstalled.cs

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ internal sealed class BuildHost : IBuildHost`
`23`	`23`	`private readonly RpcServer _server;`
`24`	`24`	`private readonly object _gate = new object();`
`25`	`25`	`private ProjectBuildManager? _buildManager;`
	`26`	`+ private MSBuildLocation? _msBuildLocation;`
`26`	`27`
`27`	`28`	`public BuildHost(BuildHostLogger logger, ImmutableDictionary<string, string> globalMSBuildProperties, string? binaryLogPath, RpcServer server)`
`28`	`29`	`{`
`@@ -32,14 +33,14 @@ public BuildHost(BuildHostLogger logger, ImmutableDictionary<string, string> glo`
`32`	`33`	`_server = server;`
`33`	`34`	`}`
`34`	`35`
`35`		`- private bool TryEnsureMSBuildLoaded(string projectOrSolutionFilePath)`
	`36`	`+ public MSBuildLocation? FindUsableMSBuild(string projectOrSolutionFilePath)`
`36`	`37`	`{`
`37`	`38`	`lock (_gate)`
`38`	`39`	`{`
`39`	`40`	`// If we've already created our MSBuild types, then there's nothing further to do.`
`40`	`41`	`if (MSBuildLocator.IsRegistered)`
`41`	`42`	`{`
`42`		`- return true;`
	`43`	`+ return _msBuildLocation;`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`if (!PlatformInformation.IsRunningOnMono)`
`@@ -59,14 +60,15 @@ private bool TryEnsureMSBuildLoaded(string projectOrSolutionFilePath)`
`59`	`60`
`60`	`61`	`// Locate the right SDK for this particular project; MSBuildLocator ensures in this case the first one is the preferred one.`
`61`	`62`	`// TODO: we should pick the appropriate instance back in the main process and just use the one chosen here.`
`62`		`- var options = new VisualStudioInstanceQueryOptions { DiscoveryTypes = DiscoveryType.DotNetSdk, WorkingDirectory = Path.GetDirectoryName(projectOrSolutionFilePath) };`
	`63`	`+ var options = new VisualStudioInstanceQueryOptions { DiscoveryTypes = DiscoveryType.DotNetSdk, WorkingDirectory = Path.GetDirectoryName(projectOrSolutionFilePath), AllowAllDotnetLocations = true, AllowAllRuntimeVersions = true };`
`63`	`64`	`instance = MSBuildLocator.QueryVisualStudioInstances(options).FirstOrDefault();`
`64`	`65`
`65`	`66`	`#endif`
`66`	`67`
`67`	`68`	`if (instance != null)`
`68`	`69`	`{`
`69`	`70`	`MSBuildLocator.RegisterInstance(instance);`
	`71`	`+ _msBuildLocation = new(instance.MSBuildPath, instance.Version.ToString());`
`70`	`72`	`_logger.LogInformation($"Registered MSBuild instance at {instance.MSBuildPath}");`
`71`	`73`	`}`
`72`	`74`	`else`
`@@ -96,7 +98,7 @@ private bool TryEnsureMSBuildLoaded(string projectOrSolutionFilePath)`
`96`	`98`	`#endif`
`97`	`99`	`}`
`98`	`100`
`99`		`- return MSBuildLocator.IsRegistered;`
	`101`	`+ return _msBuildLocation;`
`100`	`102`	`}`
`101`	`103`	`}`
`102`	`104`
`@@ -122,14 +124,9 @@ private void CreateBuildManager()`
`122`	`124`	`}`
`123`	`125`	`}`
`124`	`126`
`125`		`- public bool HasUsableMSBuild(string projectOrSolutionFilePath)`
`126`		`- {`
`127`		`- return TryEnsureMSBuildLoaded(projectOrSolutionFilePath);`
`128`		`- }`
`129`		`-`
`130`	`127`	`private void EnsureMSBuildLoaded(string projectFilePath)`
`131`	`128`	`{`
`132`		`- Contract.ThrowIfFalse(TryEnsureMSBuildLoaded(projectFilePath), $"We don't have an MSBuild to use; {nameof(HasUsableMSBuild)} should have been called first to check.");`
	`129`	`+ Contract.ThrowIfNull(FindUsableMSBuild(projectFilePath), $"We don't have an MSBuild to use; {nameof(FindUsableMSBuild)} should have been called first to check.");`
`133`	`130`	`}`
`134`	`131`
`135`	`132`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace Microsoft.CodeAnalysis.MSBuild;`
`12`	`12`	`/// </summary>`
`13`	`13`	`internal interface IBuildHost`
`14`	`14`	`{`
`15`		`- bool HasUsableMSBuild(string projectOrSolutionFilePath);`
	`15`	`+ MSBuildLocation? FindUsableMSBuild(string projectOrSolutionFilePath);`
`16`	`16`	`Task<int> LoadProjectFileAsync(string projectFilePath, string languageName, CancellationToken cancellationToken);`
`17`	`17`
`18`	`18`	`/// <summary>Permits loading a project file which only exists in-memory, for example, for file-based program scenarios.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ public RemoteBuildHost(RpcClient client)`
`19`	`19`	`_client = client;`
`20`	`20`	`}`
`21`	`21`
`22`		`- public Task<bool> HasUsableMSBuildAsync(string projectOrSolutionFilePath, CancellationToken cancellationToken)`
`23`		`- => _client.InvokeAsync<bool>(BuildHostTargetObject, nameof(IBuildHost.HasUsableMSBuild), parameters: [projectOrSolutionFilePath], cancellationToken);`
	`22`	`+ public Task<MSBuildLocation> FindUsableMSBuildAsync(string projectOrSolutionFilePath, CancellationToken cancellationToken)`
	`23`	`+ => _client.InvokeAsync<MSBuildLocation>(BuildHostTargetObject, nameof(IBuildHost.FindUsableMSBuild), parameters: [projectOrSolutionFilePath], cancellationToken);`
`24`	`24`
`25`	`25`	`public async Task<RemoteProjectFile> LoadProjectFileAsync(string projectFilePath, string languageName, CancellationToken cancellationToken)`
`26`	`26`	`{`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ private static bool HasNetCoreSdkForSolution(string solution)`
`44`	`44`
`45`	`45`	`var buildHost = buildHostProcessManager.GetBuildHostAsync(BuildHostProcessManager.BuildHostProcessKind.NetCore, CancellationToken.None).Result;`
`46`	`46`
`47`		`- return buildHost.HasUsableMSBuildAsync(solution, CancellationToken.None).Result;`
	`47`	`+ return buildHost.FindUsableMSBuildAsync(solution, CancellationToken.None).Result is not null;`
`48`	`48`	`}`
`49`	`49`	`finally`
`50`	`50`	`{`