Skip redundant per-task environment apply/restore in the task host

When a task host runs consecutive tasks whose environment is unchanged and the previous task did not mutate it, skip re-applying and restoring the process environment. Reset the cache at build boundaries and whenever a task blocks on a callback, so nested activity always forces a fresh apply.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: OvesN

src/Build.UnitTests/BackEnd/TaskHostFactory_Tests.cs

@@ -257,6 +257,65 @@ public void TransientAndSidecarNodeCanCoexist()
             }
         }
 
+        /// <summary>
+        /// Regression test for the out-of-proc task host environment-reuse optimization, which lets the host skip
+        /// re-applying the (unchanged) build process environment between consecutive tasks. The load-bearing
+        /// assertion is that all three tasks run in the SAME reused task host process (a shared task-host process
+        /// id, distinct from this build process), proving the skip path was actually exercised. Each invocation --
+        /// including ones whose apply was skipped -- must also still observe a consistent build environment.
+        /// (Note: the variable is also inherited by the child process, so the read alone does not isolate the
+        /// apply; the dedicated coverage for apply correctness is the serialization and -mt change-propagation
+        /// tests.)
+        /// </summary>
+        [Fact]
+        public void TaskHostObservesEnvironmentAcrossConsecutiveTasks()
+        {
+            using TestEnvironment env = TestEnvironment.Create(_output);
+
+            string variableName = "MSBUILD_ENV_REUSE_TEST_" + Guid.NewGuid().ToString("N");
+            const string variableValue = "reuse_value_123";
+            env.SetEnvironmentVariable(variableName, variableValue);
+            env.SetEnvironmentVariable("MSBUILDFORCEALLTASKSOUTOFPROC", "1");
+
+            string projectContents = $@"
+<Project>
+    <UsingTask TaskName=""{nameof(ReadEnvironmentVariableTask)}"" AssemblyFile=""{typeof(ReadEnvironmentVariableTask).Assembly.Location}"" TaskFactory=""TaskHostFactory"" />
+    <Target Name='Build'>
+        <{nameof(ReadEnvironmentVariableTask)} VariableName=""{variableName}"">
+            <Output PropertyName=""Value1"" TaskParameter=""Value"" />
+            <Output PropertyName=""Pid1"" TaskParameter=""Pid"" />
+        </{nameof(ReadEnvironmentVariableTask)}>
+        <{nameof(ReadEnvironmentVariableTask)} VariableName=""{variableName}"">
+            <Output PropertyName=""Value2"" TaskParameter=""Value"" />
+            <Output PropertyName=""Pid2"" TaskParameter=""Pid"" />
+        </{nameof(ReadEnvironmentVariableTask)}>
+        <{nameof(ReadEnvironmentVariableTask)} VariableName=""{variableName}"">
+            <Output PropertyName=""Value3"" TaskParameter=""Value"" />
+            <Output PropertyName=""Pid3"" TaskParameter=""Pid"" />
+        </{nameof(ReadEnvironmentVariableTask)}>
+    </Target>
+</Project>";
+
+            TransientTestFile project = env.CreateFile("envReuseProject.csproj", projectContents);
+            ProjectInstance projectInstance = new(project.Path);
+
+            projectInstance.Build().ShouldBeTrue();
+
+            // Every task invocation -- including ones whose environment apply was skipped because the environment
+            // was unchanged from the previous task -- must still observe the build-set variable.
+            projectInstance.GetPropertyValue("Value1").ShouldBe(variableValue);
+            projectInstance.GetPropertyValue("Value2").ShouldBe(variableValue);
+            projectInstance.GetPropertyValue("Value3").ShouldBe(variableValue);
+
+            // All three invocations should have run in the same task host process (so the reuse path was actually
+            // exercised) and not in the current build process.
+            string pid1 = projectInstance.GetPropertyValue("Pid1");
+            pid1.ShouldNotBeNullOrEmpty();
+            pid1.ShouldBe(projectInstance.GetPropertyValue("Pid2"));
+            pid1.ShouldBe(projectInstance.GetPropertyValue("Pid3"));
+            pid1.ShouldNotBe(Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture));
+        }
+
         /// <summary>
         /// Regression test for the out-of-proc task host forward environment-delta optimization (#14097). To avoid
         /// re-transmitting the (invariant) build process environment in every <see cref="TaskHostConfiguration"/>,

src/MSBuild/OutOfProcTaskHostNode.cs

@@ -104,6 +104,15 @@ internal class OutOfProcTaskHostNode :
         /// </summary>
         private string _forwardSolutionConfigBaseline;
 
+        /// <summary>
+        /// The build process environment whose values are currently reflected in this task host process. Used to
+        /// skip the redundant per-task environment apply + restore when the next task's environment is identical
+        /// and the previous task did not mutate it. Set to <see langword="null"/> whenever a task blocks on a
+        /// callback (<see cref="SaveOperatingEnvironment"/>) or the node is reused for a new build, so nested
+        /// activity and build boundaries always force a fresh apply.
+        /// </summary>
+        private IDictionary<string, string> _lastAppliedConfigEnvironment;
+
         /// <summary>
         /// The event which is set when we should shut down.
         /// </summary>
@@ -1137,6 +1146,9 @@ private void SaveOperatingEnvironment(TaskExecutionContext context)
         {
             ArgumentNullException.ThrowIfNull(context);
 
+            // A task is about to block and let a nested task run, which may change the process environment.
+            _lastAppliedConfigEnvironment = null;
+
             context.SavedCurrentDirectory = Environment.CurrentDirectory;
             context.SavedEnvironment = new Dictionary<string, string>(
                 CommunicationsUtilities.GetEnvironmentVariables(),
@@ -1312,6 +1324,10 @@ private void HandleNodeBuildComplete(NodeBuildComplete buildComplete)
         {
             Assumed.Zero(_activeTaskCount, "We should never have a task in the process of executing when we receive NodeBuildComplete.");
 
+            // When this node is reused for a later build, reset the environment-reuse cache so the first task of
+            // the next build performs a fresh apply rather than trusting state left over from this build.
+            _lastAppliedConfigEnvironment = null;
+
             // Sidecar TaskHost will persist after the build is done.
             if (_nodeReuse)
             {
@@ -1476,14 +1492,24 @@ private void RunTask(object state)
                 // Change to the startup directory
                 NativeMethodsShared.SetCurrentDirectory(taskConfiguration.StartupDirectory);
 
-                if (_updateEnvironment)
+                bool canSkipEnvironmentApply = _lastAppliedConfigEnvironment is not null
+                    && _blockedTaskCount == 0
+                    && _activeTaskCount == 1
+                    && CommunicationsUtilities.AreEnvironmentsEquivalent(taskConfiguration.BuildProcessEnvironment, _lastAppliedConfigEnvironment);
+
+                if (!canSkipEnvironmentApply)
                 {
-                    InitializeMismatchedEnvironmentTable(taskConfiguration.BuildProcessEnvironment);
+                    if (_updateEnvironment)
+                    {
+                        InitializeMismatchedEnvironmentTable(taskConfiguration.BuildProcessEnvironment);
+                    }
+
+                    // Now set the new environment
+                    SetTaskHostEnvironment(taskConfiguration.BuildProcessEnvironment);
+                    DotnetHostEnvironmentHelper.ClearBootstrapDotnetRootEnvironment(taskConfiguration.BuildProcessEnvironment);
                 }
 
-                // Now set the new environment
-                SetTaskHostEnvironment(taskConfiguration.BuildProcessEnvironment);
-                DotnetHostEnvironmentHelper.ClearBootstrapDotnetRootEnvironment(taskConfiguration.BuildProcessEnvironment);
+                _lastAppliedConfigEnvironment = taskConfiguration.BuildProcessEnvironment;
 
                 // Set culture
                 Thread.CurrentThread.CurrentCulture = taskConfiguration.Culture;
@@ -1567,8 +1593,16 @@ private void RunTask(object state)
                     }
 #endif
 
-                    // Restore the original clean environment
-                    CommunicationsUtilities.SetEnvironment(_savedEnvironment);
+                    bool canSkipEnvironmentRestore = environmentUnchangedByTask
+                        && _blockedTaskCount == 0
+                        && ReferenceEquals(_lastAppliedConfigEnvironment, taskConfiguration.BuildProcessEnvironment);
+
+                    if (!canSkipEnvironmentRestore)
+                    {
+                        // Restore the original clean environment
+                        CommunicationsUtilities.SetEnvironment(_savedEnvironment);
+                        _lastAppliedConfigEnvironment = null;
+                    }
                 }
                 catch (Exception e)
                 {