update runcommand target framework selection to use evaluator

src/Cli/dotnet/Commands/Run/RunCommand.cs

@@ -21,6 +21,7 @@
 using Microsoft.DotNet.Cli.MSBuildEvaluation;
 using Microsoft.DotNet.FileBasedPrograms;
 using Microsoft.DotNet.ProjectTools;
+using NuGet.Frameworks;
 
 namespace Microsoft.DotNet.Cli.Commands.Run;
 
@@ -129,8 +130,10 @@ public int Execute()
             return 1;
         }
 
+        using var topLevelEvaluator = DotNetProjectEvaluatorFactory.CreateForCommand(MSBuildArgs);
+
         // Pre-run evaluation: Handle target framework selection for multi-targeted projects
-        if (ProjectFileFullPath is not null && !TrySelectTargetFrameworkIfNeeded())
+        if (ProjectFileFullPath is not null && !TrySelectTargetFrameworkIfNeeded(topLevelEvaluator))
         {
             return 1;
         }
@@ -205,16 +208,15 @@ public int Execute()
     /// If needed and we're in non-interactive mode, shows an error.
     /// </summary>
     /// <returns>True if we can continue, false if we should exit</returns>
-    private bool TrySelectTargetFrameworkIfNeeded()
+    private bool TrySelectTargetFrameworkIfNeeded(DotNetProjectEvaluator evaluator)
     {
         Debug.Assert(ProjectFileFullPath is not null);
 
-        var globalProperties = CommonRunHelpers.GetGlobalPropertiesFromArgs(MSBuildArgs);
         if (TargetFrameworkSelector.TrySelectTargetFramework(
             ProjectFileFullPath,
-            globalProperties,
+            evaluator,
             Interactive,
-            out string? selectedFramework))
+            out NuGetFramework? selectedFramework))
         {
             ApplySelectedFramework(selectedFramework);
             return true;
@@ -248,7 +250,7 @@ private bool TrySelectTargetFrameworkForFileBasedProject()
         }
 
         // Use TargetFrameworkSelector to handle multi-target selection (or single framework selection)
-        if (TargetFrameworkSelector.TrySelectTargetFramework(frameworks, Interactive, out string? selectedFramework))
+        if (TargetFrameworkSelector.TrySelectTargetFramework(frameworks, Interactive, out var selectedFramework))
         {
             ApplySelectedFramework(selectedFramework);
             return true;
@@ -261,7 +263,7 @@ private bool TrySelectTargetFrameworkForFileBasedProject()
     /// Parses a source file to extract target frameworks from directives.
     /// </summary>
     /// <returns>Array of frameworks if TargetFrameworks is specified, null otherwise</returns>
-    private static string[]? GetTargetFrameworksFromSourceFile(string sourceFilePath)
+    private static NuGetFramework[]? GetTargetFrameworksFromSourceFile(string sourceFilePath)
     {
         var sourceFile = SourceFile.Load(sourceFilePath);
         var directives = FileLevelDirectiveHelpers.FindDirectives(sourceFile, reportAllErrors: false, ErrorReporters.IgnoringReporter);
@@ -274,21 +276,21 @@ private bool TrySelectTargetFrameworkForFileBasedProject()
             return null;
         }
 
-        return targetFrameworksDirective.Value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        return targetFrameworksDirective.Value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).Select(NuGetFramework.Parse).ToArray();
     }
 
     /// <summary>
     /// Applies the selected target framework to MSBuildArgs if a framework was provided.
     /// </summary>
     /// <param name="selectedFramework">The framework to apply, or null if no framework selection was needed</param>
-    private void ApplySelectedFramework(string? selectedFramework)
+    private void ApplySelectedFramework(NuGetFramework? selectedFramework)
     {
         // If selectedFramework is null, it means no framework selection was needed
         // (e.g., user already specified --framework, or single-target project)
         if (selectedFramework is not null)
         {
             var additionalProperties = new ReadOnlyDictionary<string, string>(
-                new Dictionary<string, string> { { "TargetFramework", selectedFramework } });
+                new Dictionary<string, string> { { "TargetFramework", selectedFramework.GetShortFolderName() } });
             MSBuildArgs = MSBuildArgs.CloneWithAdditionalProperties(additionalProperties);
         }
     }

src/Cli/dotnet/Commands/Run/TargetFrameworkSelector.cs

@@ -1,9 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.Build.Evaluation;
-using Microsoft.Build.Exceptions;
+using Microsoft.DotNet.Cli.MSBuildEvaluation;
 using Microsoft.DotNet.Cli.Utils;
+using NuGet.Frameworks;
 using Spectre.Console;
 
 namespace Microsoft.DotNet.Cli.Commands.Run;
@@ -21,43 +21,31 @@ internal static class TargetFrameworkSelector
     /// <returns>True if we should continue, false if we should exit with error</returns>
     public static bool TrySelectTargetFramework(
         string projectFilePath,
-        Dictionary<string, string> globalProperties,
+        DotNetProjectEvaluator evaluator,
         bool isInteractive,
-        out string? selectedFramework)
+        out NuGetFramework? selectedFramework)
     {
         selectedFramework = null;
 
         // If a framework is already specified, no need to prompt
-        if (globalProperties.TryGetValue("TargetFramework", out var existingFramework) && !string.IsNullOrWhiteSpace(existingFramework))
+        if (evaluator.GlobalProperties.TryGetValue("TargetFramework", out var existingFramework) && !string.IsNullOrWhiteSpace(existingFramework))
         {
             return true;
         }
 
         // Evaluate the project to get TargetFrameworks
-        string targetFrameworks;
-        try
-        {
-            using var collection = new ProjectCollection(globalProperties: globalProperties);
-            var project = collection.LoadProject(projectFilePath);
-            targetFrameworks = project.GetPropertyValue("TargetFrameworks");
-        }
-        catch (InvalidProjectFileException)
-        {
-            // Invalid project file, return true to continue for normal error handling
-            return true;
-        }
+        var project = evaluator.LoadProject(projectFilePath, additionalGlobalProperties: null, useFlexibleLoading: true);
+        var targetFrameworks = project.TargetFrameworks;
 
         // If there's no TargetFrameworks property or only one framework, no selection needed
-        if (string.IsNullOrWhiteSpace(targetFrameworks))
+        if (targetFrameworks is null or { Length: 0 or 1 })
         {
             return true;
         }
 
         // parse the TargetFrameworks property and make sure to account for any additional whitespace
         // users may have added for formatting reasons.
-        var frameworks = targetFrameworks.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-
-        return TrySelectTargetFramework(frameworks, isInteractive, out selectedFramework);
+        return TrySelectTargetFramework(targetFrameworks, isInteractive, out selectedFramework);
     }
 
     /// <summary>
@@ -69,7 +57,7 @@ public static bool TrySelectTargetFramework(
     /// <param name="isInteractive">Whether we're running in interactive mode (can prompt user)</param>
     /// <param name="selectedFramework">The selected target framework, or null if selection was cancelled</param>
     /// <returns>True if we should continue, false if we should exit with error</returns>
-    public static bool TrySelectTargetFramework(string[] frameworks, bool isInteractive, out string? selectedFramework)
+    public static bool TrySelectTargetFramework(NuGetFramework[] frameworks, bool isInteractive, out NuGetFramework? selectedFramework)
     {
         // If there's only one framework in the TargetFrameworks, we do need to pick it to force the subsequent builds/evaluations
         // to act against the correct 'view' of the project
@@ -107,15 +95,16 @@ public static bool TrySelectTargetFramework(string[] frameworks, bool isInteract
     /// <summary>
     /// Prompts the user to select a target framework from the available options using Spectre.Console.
     /// </summary>
-    private static string? PromptForTargetFramework(string[] frameworks)
+    private static NuGetFramework? PromptForTargetFramework(NuGetFramework[] frameworks)
     {
         try
         {
-            var prompt = new SelectionPrompt<string>()
+            var prompt = new SelectionPrompt<NuGetFramework>()
                 .Title($"[cyan]{Markup.Escape(CliCommandStrings.RunCommandSelectTargetFrameworkPrompt)}[/]")
                 .PageSize(10)
                 .MoreChoicesText($"[grey]({Markup.Escape(CliCommandStrings.RunCommandMoreFrameworksText)})[/]")
                 .AddChoices(frameworks)
+                .UseConverter(framework => framework.GetShortFolderName())
                 .EnableSearch()
                 .SearchPlaceholderText(CliCommandStrings.RunCommandSearchPlaceholderText);