Avoid unnecessary evaluations during dotnet run file.cs (#49991)

Author: jjonescz

src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildArgs.cs

@@ -167,11 +167,11 @@ public MSBuildArgs CloneWithAdditionalProperties(ReadOnlyDictionary<string, stri
         return new MSBuildArgs(new(newProperties), RestoreGlobalProperties, RequestedTargets, Verbosity, OtherMSBuildArgs.ToArray());
     }
 
-    public MSBuildArgs CloneWithAdditionalTarget(string additionalTarget)
+    public MSBuildArgs CloneWithAdditionalTargets(params ReadOnlySpan<string> additionalTargets)
     {
         string[] newTargets = RequestedTargets is not null
-            ? [.. RequestedTargets, additionalTarget]
-            : [ additionalTarget ];
+            ? [.. RequestedTargets, .. additionalTargets]
+            : [.. additionalTargets];
         return new MSBuildArgs(GlobalProperties, RestoreGlobalProperties, newTargets, Verbosity, OtherMSBuildArgs.ToArray());
     }
 

src/Cli/dotnet/Commands/Restore/RestoringCommand.cs

@@ -125,7 +125,7 @@ private static MSBuildArgs GetCommandArguments(
             .ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase) is { } filteredList ? new(filteredList): ReadOnlyDictionary<string, string>.Empty;
         var restoreMSBuildArgs =
             MSBuildArgs.FromProperties(RestoreOptimizationProperties)
-                       .CloneWithAdditionalTarget("Restore")
+                       .CloneWithAdditionalTargets("Restore")
                        .CloneWithExplicitArgs([.. newArgumentsToAdd, .. existingArgumentsToForward])
                        .CloneWithAdditionalProperties(restoreProperties);
         if (msbuildArgs.Verbosity is {} verbosity)

src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs

@@ -111,7 +111,7 @@ public override RunApiOutput Execute()
                 msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty);
 
             runCommand.TryGetLaunchProfileSettingsIfNeeded(out var launchSettings);
-            var targetCommand = (Utils.Command)runCommand.GetTargetCommand(buildCommand.CreateProjectInstance);
+            var targetCommand = (Utils.Command)runCommand.GetTargetCommand(buildCommand.CreateProjectInstance, cachedRunProperties: null);
             runCommand.ApplyLaunchSettingsProfileToCommand(targetCommand, launchSettings);
 
             return new RunApiOutput.RunCommand

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

@@ -129,10 +129,6 @@ static int ProcessBuildResponse(BuildResponse response, out bool fallbackToNorma
 
     private void PrepareAuxiliaryFiles(out string rspPath)
     {
-        Reporter.Verbose.WriteLine(CanReuseAuxiliaryFiles
-            ? "CSC auxiliary files can be reused."
-            : "CSC auxiliary files can NOT be reused.");
-
         string fileDirectory = Path.GetDirectoryName(EntryPointFileFullPath) ?? string.Empty;
         string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(EntryPointFileFullPath);
 

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

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Frozen;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
 using System.CommandLine;
@@ -124,14 +123,15 @@ public int Execute()
         }
 
         Func<ProjectCollection, ProjectInstance>? projectFactory = null;
+        RunProperties? cachedRunProperties = null;
         if (ShouldBuild)
         {
             if (string.Equals("true", launchSettings?.DotNetRunMessages, StringComparison.OrdinalIgnoreCase))
             {
                 Reporter.Output.WriteLine(CliCommandStrings.RunCommandBuilding);
             }
 
-            EnsureProjectIsBuilt(out projectFactory);
+            EnsureProjectIsBuilt(out projectFactory, out cachedRunProperties);
         }
         else
         {
@@ -145,13 +145,16 @@ public int Execute()
                 Debug.Assert(!ReadCodeFromStdin);
                 var command = CreateVirtualCommand();
                 command.MarkArtifactsFolderUsed();
-                projectFactory = command.CreateProjectInstance;
+
+                var cacheEntry = command.GetPreviousCacheEntry();
+                projectFactory = CanUseRunPropertiesForCscBuiltProgram(BuildLevel.None, cacheEntry) ? null : command.CreateProjectInstance;
+                cachedRunProperties = cacheEntry?.Run;
             }
         }
 
         try
         {
-            ICommand targetCommand = GetTargetCommand(projectFactory);
+            ICommand targetCommand = GetTargetCommand(projectFactory, cachedRunProperties);
             ApplyLaunchSettingsProfileToCommand(targetCommand, launchSettings);
 
             // Env variables specified on command line override those specified in launch profile:
@@ -294,22 +297,24 @@ internal bool TryGetLaunchProfileSettingsIfNeeded(out ProjectLaunchSettingsModel
         }
     }
 
-    private void EnsureProjectIsBuilt(out Func<ProjectCollection, ProjectInstance>? projectFactory)
+    private void EnsureProjectIsBuilt(out Func<ProjectCollection, ProjectInstance>? projectFactory, out RunProperties? cachedRunProperties)
     {
         int buildResult;
         if (EntryPointFileFullPath is not null)
         {
             var command = CreateVirtualCommand();
             buildResult = command.Execute();
-            projectFactory = command.LastBuildLevel is BuildLevel.Csc ? null : command.CreateProjectInstance;
+            projectFactory = CanUseRunPropertiesForCscBuiltProgram(command.LastBuild.Level, command.LastBuild.Cache?.PreviousEntry) ? null : command.CreateProjectInstance;
+            cachedRunProperties = command.LastBuild.Cache?.CurrentEntry.Run;
         }
         else
         {
             Debug.Assert(ProjectFileFullPath is not null);
 
             projectFactory = null;
+            cachedRunProperties = null;
             buildResult = new RestoringCommand(
-                MSBuildArgs.CloneWithExplicitArgs([ProjectFileFullPath, ..MSBuildArgs.OtherMSBuildArgs]),
+                MSBuildArgs.CloneWithExplicitArgs([ProjectFileFullPath, .. MSBuildArgs.OtherMSBuildArgs]),
                 NoRestore,
                 advertiseWorkloadUpdates: false
             ).Execute();
@@ -322,13 +327,23 @@ private void EnsureProjectIsBuilt(out Func<ProjectCollection, ProjectInstance>?
         }
     }
 
+    private static bool CanUseRunPropertiesForCscBuiltProgram(BuildLevel level, RunFileBuildCacheEntry? previousCache)
+    {
+        return level == BuildLevel.Csc ||
+            (level == BuildLevel.None && previousCache?.BuildLevel == BuildLevel.Csc);
+    }
+
     private VirtualProjectBuildingCommand CreateVirtualCommand()
     {
         Debug.Assert(EntryPointFileFullPath != null);
 
+        var args = MSBuildArgs.RequestedTargets is null or []
+            ? MSBuildArgs.CloneWithAdditionalTargets("Build", ComputeRunArgumentsTarget)
+            : MSBuildArgs.CloneWithAdditionalTargets(ComputeRunArgumentsTarget);
+
         return new(
             entryPointFileFullPath: EntryPointFileFullPath,
-            msbuildArgs: MSBuildArgs)
+            msbuildArgs: args)
         {
             NoRestore = NoRestore,
             NoCache = NoCache,
@@ -361,23 +376,33 @@ private MSBuildArgs SetupSilentBuildArgs(MSBuildArgs msbuildArgs)
         }
     }
 
-    internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? projectFactory)
+    internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? projectFactory, RunProperties? cachedRunProperties)
     {
         if (projectFactory is null && ProjectFileFullPath is null)
         {
             // If we are running a file-based app and projectFactory is null, it means csc was used instead of full msbuild.
             // So we can skip project evaluation to continue the optimized path.
             Debug.Assert(EntryPointFileFullPath is not null);
+            Reporter.Verbose.WriteLine("Getting target command: for csc-built program.");
             return CreateCommandForCscBuiltProgram(EntryPointFileFullPath);
         }
 
+        if (cachedRunProperties != null)
+        {
+            // We can also skip project evaluation if we already evaluated the project during virtual build
+            // or we have cached run properties in previous run (and this is a --no-build run).
+            Reporter.Verbose.WriteLine("Getting target command: from cache.");
+            return CreateCommandFromRunProperties(cachedRunProperties.WithApplicationArguments(ApplicationArgs));
+        }
+
+        Reporter.Verbose.WriteLine("Getting target command: evaluating project.");
         FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. MSBuildArgs.OtherMSBuildArgs], "dotnet-run");
         var project = EvaluateProject(ProjectFileFullPath, projectFactory, MSBuildArgs, logger);
         ValidatePreconditions(project);
         InvokeRunArgumentsTarget(project, NoBuild, logger, MSBuildArgs);
         logger?.ReallyShutdown();
-        var runProperties = ReadRunPropertiesFromProject(project, ApplicationArgs);
-        var command = CreateCommandFromRunProperties(project, runProperties);
+        var runProperties = RunProperties.FromProject(project).WithApplicationArguments(ApplicationArgs);
+        var command = CreateCommandFromRunProperties(runProperties);
         return command;
 
         static ProjectInstance EvaluateProject(string? projectFilePath, Func<ProjectCollection, ProjectInstance>? projectFactory, MSBuildArgs msbuildArgs, ILogger? binaryLogger)
@@ -407,29 +432,18 @@ static void ValidatePreconditions(ProjectInstance project)
             }
         }
 
-        static RunProperties ReadRunPropertiesFromProject(ProjectInstance project, string[] applicationArgs)
-        {
-            var runProperties = RunProperties.FromProjectAndApplicationArguments(project, applicationArgs);
-            if (string.IsNullOrEmpty(runProperties.RunCommand))
-            {
-                ThrowUnableToRunError(project);
-            }
-
-            return runProperties;
-        }
-
-        static ICommand CreateCommandFromRunProperties(ProjectInstance project, RunProperties runProperties)
+        static ICommand CreateCommandFromRunProperties(RunProperties runProperties)
         {
-            CommandSpec commandSpec = new(runProperties.RunCommand, runProperties.RunArguments);
+            CommandSpec commandSpec = new(runProperties.Command, runProperties.Arguments);
 
             var command = CommandFactoryUsingResolver.Create(commandSpec)
-                .WorkingDirectory(runProperties.RunWorkingDirectory);
+                .WorkingDirectory(runProperties.WorkingDirectory);
 
             SetRootVariableName(
                 command,
-                project.GetPropertyValue("RuntimeIdentifier"),
-                project.GetPropertyValue("DefaultAppHostRuntimeIdentifier"),
-                project.GetPropertyValue("TargetFrameworkVersion"));
+                runtimeIdentifier: runProperties.RuntimeIdentifier,
+                defaultAppHostRuntimeIdentifier: runProperties.DefaultAppHostRuntimeIdentifier,
+                targetFrameworkVersion: runProperties.TargetFrameworkVersion);
 
             return command;
         }
@@ -482,7 +496,7 @@ static void InvokeRunArgumentsTarget(ProjectInstance project, bool noBuild, Faca
 
     static readonly string ComputeRunArgumentsTarget = "ComputeRunArguments";
 
-    private static void ThrowUnableToRunError(ProjectInstance project)
+    internal static void ThrowUnableToRunError(ProjectInstance project)
     {
         string targetFrameworks = project.GetPropertyValue("TargetFrameworks");
         if (!string.IsNullOrEmpty(targetFrameworks))
@@ -585,7 +599,7 @@ private static void ThrowUnableToRunError(ProjectInstance project)
 
     public static RunCommand FromArgs(string[] args)
     {
-        var parseResult = Parser.Parse(["dotnet", "run", ..args]);
+        var parseResult = Parser.Parse(["dotnet", "run", .. args]);
         return FromParseResult(parseResult);
     }
 

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

@@ -6,19 +6,44 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Run;
 
-internal record RunProperties(string RunCommand, string? RunArguments, string? RunWorkingDirectory)
+internal sealed record RunProperties(
+    string Command,
+    string? Arguments,
+    string? WorkingDirectory,
+    string RuntimeIdentifier,
+    string DefaultAppHostRuntimeIdentifier,
+    string TargetFrameworkVersion)
 {
-    internal static RunProperties FromProjectAndApplicationArguments(ProjectInstance project, string[] applicationArgs)
+    internal RunProperties(string command, string? arguments, string? workingDirectory)
+        : this(command, arguments, workingDirectory, string.Empty, string.Empty, string.Empty)
     {
-        string runProgram = project.GetPropertyValue("RunCommand");
-        string runArguments = project.GetPropertyValue("RunArguments");
-        string runWorkingDirectory = project.GetPropertyValue("RunWorkingDirectory");
+    }
+
+    internal static RunProperties FromProject(ProjectInstance project)
+    {
+        var result = new RunProperties(
+            Command: project.GetPropertyValue("RunCommand"),
+            Arguments: project.GetPropertyValue("RunArguments"),
+            WorkingDirectory: project.GetPropertyValue("RunWorkingDirectory"),
+            RuntimeIdentifier: project.GetPropertyValue("RuntimeIdentifier"),
+            DefaultAppHostRuntimeIdentifier: project.GetPropertyValue("DefaultAppHostRuntimeIdentifier"),
+            TargetFrameworkVersion: project.GetPropertyValue("TargetFrameworkVersion"));
 
+        if (string.IsNullOrEmpty(result.Command))
+        {
+            RunCommand.ThrowUnableToRunError(project);
+        }
+
+        return result;
+    }
+
+    internal RunProperties WithApplicationArguments(string[] applicationArgs)
+    {
         if (applicationArgs.Length != 0)
         {
-            runArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(applicationArgs);
+            return this with { Arguments = Arguments + " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(applicationArgs) };
         }
 
-        return new(runProgram, runArguments, runWorkingDirectory);
+        return this;
     }
 }