Multithreading migration: Group 11 — 5 Framework & Environment tasks (Pattern B)

src/Cli/Microsoft.DotNet.Configurer/CliFolderPathCalculator.cs

@@ -46,7 +46,7 @@ public static string DotnetHomePath
         {
             get
             {
-                return CliFolderPathCalculatorCore.GetDotnetHomePath()
+                return new CliFolderPathCalculatorCore().GetDotnetHomePath()
                     ?? throw new ConfigurationException(
                             string.Format(
                                 LocalizableStrings.FailedToDetermineUserHomeDirectory,

src/Common/CliFolderPathCalculatorCore.cs

@@ -3,12 +3,31 @@
 
 namespace Microsoft.DotNet.Configurer
 {
-    static class CliFolderPathCalculatorCore
+    class CliFolderPathCalculatorCore
     {
         public const string DotnetHomeVariableName = "DOTNET_CLI_HOME";
         public const string DotnetProfileDirectoryName = ".dotnet";
 
-        public static string? GetDotnetUserProfileFolderPath()
+        private readonly Func<string, string?> _getEnvironmentVariable;
+
+        /// <summary>
+        /// Creates an instance that reads environment variables from the process environment.
+        /// </summary>
+        public CliFolderPathCalculatorCore()
+            : this(Environment.GetEnvironmentVariable)
+        {
+        }
+
+        /// <summary>
+        /// Creates an instance that reads environment variables via the supplied delegate.
+        /// Use this from MSBuild tasks to route reads through TaskEnvironment.
+        /// </summary>
+        public CliFolderPathCalculatorCore(Func<string, string?> getEnvironmentVariable)
+        {
+            _getEnvironmentVariable = getEnvironmentVariable ?? throw new ArgumentNullException(nameof(getEnvironmentVariable));
+        }
+
+        public string? GetDotnetUserProfileFolderPath()
         {
             string? homePath = GetDotnetHomePath();
             if (homePath is null)
@@ -19,9 +38,9 @@ static class CliFolderPathCalculatorCore
             return Path.Combine(homePath, DotnetProfileDirectoryName);
         }
 
-        public static string? GetDotnetHomePath()
+        public string? GetDotnetHomePath()
         {
-            var home = Environment.GetEnvironmentVariable(DotnetHomeVariableName);
+            var home = _getEnvironmentVariable(DotnetHomeVariableName);
             if (string.IsNullOrEmpty(home))
             {
                 home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
@@ -33,5 +52,6 @@ static class CliFolderPathCalculatorCore
 
             return home;
         }
+
     }
 }

src/RazorSdk/Tool/ServerCommand.cs

@@ -169,7 +169,7 @@ internal static string GetPidFilePath()
             var path = Environment.GetEnvironmentVariable("DOTNET_BUILD_PIDFILE_DIRECTORY");
             if (string.IsNullOrEmpty(path))
             {
-                var homePath = CliFolderPathCalculatorCore.GetDotnetHomePath();
+                var homePath = new CliFolderPathCalculatorCore().GetDotnetHomePath();
                 if (homePath is null)
                 {
                     // Couldn't locate the user profile directory. Bail.

src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/MSBuildSdkResolver.cs

@@ -308,7 +308,7 @@ private sealed class CachedState
             };
 
             //  First check if requested SDK resolves to a workload SDK pack
-            string? userProfileDir = CliFolderPathCalculatorCore.GetDotnetUserProfileFolderPath();
+            string? userProfileDir = new CliFolderPathCalculatorCore().GetDotnetUserProfileFolderPath();
             ResolutionResult? workloadResult = null;
             if (dotnetRoot is not null && netcoreSdkVersion is not null)
             {

src/Resolvers/Microsoft.NET.Sdk.WorkloadMSBuildSdkResolver/WorkloadSdkResolver.cs

@@ -62,7 +62,7 @@ private class CachedState
                 resolverContext.State = cachedState;
             }
 
-            string? userProfileDir = CliFolderPathCalculatorCore.GetDotnetUserProfileFolderPath();
+            string? userProfileDir = new CliFolderPathCalculatorCore().GetDotnetUserProfileFolderPath();
             ResolutionResult? result = null;
             if (cachedState.DotnetRootPath is not null && cachedState.SdkVersion is not null)
             {

src/Tasks/Common/ProcessTaskEnvironmentDriver.cs

@@ -103,6 +103,7 @@ public ProcessStartInfo GetProcessStartInfo()
             var startInfo = new ProcessStartInfo
             {
                 WorkingDirectory = _projectDirectory.Value,
+                UseShellExecute = false,
             };
 
             // Populate environment from the scoped environment dictionary

src/Tasks/Common/TaskEnvironmentDefaults.cs

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Provides a default TaskEnvironment for single-threaded MSBuild execution.
+// When MSBuild supports IMultiThreadableTask, it sets TaskEnvironment directly.
+// This fallback ensures tasks work with older MSBuild versions that do not set it.
+
+#if NETFRAMEWORK
+
+using System;
+
+namespace Microsoft.Build.Framework
+{
+    internal static class TaskEnvironmentDefaults
+    {
+        /// <summary>
+        /// Creates a default TaskEnvironment backed by the current process environment.
+        /// Uses Environment.CurrentDirectory as the project directory, which in single-threaded
+        /// MSBuild is set to the project directory before task execution.
+        /// </summary>
+        internal static TaskEnvironment Create() =>
+            new TaskEnvironment(new ProcessTaskEnvironmentDriver(Environment.CurrentDirectory));
+    }
+}
+
+#endif

src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenADependencyContextBuilder.cs

@@ -73,7 +73,7 @@ public void ItBuildsDependencyContextsFromProjectLockFiles(
                 .Build();
 
             JObject result = Save(dependencyContext);
-            JObject baseline = ReadJson($"{baselineFileName}.deps.json");
+            JObject baseline = ReadJson(Path.Combine(TestLockFiles.TestAssemblyDirectory, $"{baselineFileName}.deps.json"));
 
             try
             {

src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenAProcessFrameworkReferencesMultiThreading.cs

@@ -0,0 +1,145 @@
+// 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.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Build.Framework;
+using Xunit;
+
+namespace Microsoft.NET.Build.Tasks.UnitTests
+{
+    [Collection("CWD-Dependent")]
+
+    public class GivenAProcessFrameworkReferencesMultiThreading
+    {
+        [Fact]
+        public void EmptyFrameworkReferences_DoesNotCrash()
+        {
+            var task = new ProcessFrameworkReferences
+            {
+                BuildEngine = new MockBuildEngine(),
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
+                TargetFrameworkVersion = "8.0",
+                TargetingPackRoot = "",
+                RuntimeGraphPath = "",
+                FrameworkReferences = Array.Empty<ITaskItem>(),
+                KnownFrameworkReferences = Array.Empty<ITaskItem>(),
+                KnownRuntimePacks = Array.Empty<ITaskItem>(),
+                KnownCrossgen2Packs = Array.Empty<ITaskItem>(),
+                KnownILCompilerPacks = Array.Empty<ITaskItem>(),
+                KnownILLinkPacks = Array.Empty<ITaskItem>(),
+                KnownWebAssemblySdkPacks = Array.Empty<ITaskItem>(),
+            };
+
+            // Should not throw; may return true (nothing to process) or false (missing required props)
+            var act = () => task.Execute();
+            act.Should().NotThrow("empty framework references should be handled gracefully");
+        }
+
+        [Fact]
+        public void ProjectDirectory_UsedInsteadOfEnvironmentCurrentDirectory()
+        {
+            // Verify that the task uses TaskEnvironment.ProjectDirectory for global.json search
+            // instead of Environment.CurrentDirectory
+            var projectDir = Path.Combine(Path.GetTempPath(), "pfr-mt-" + Guid.NewGuid().ToString("N"));
+            var otherDir = Path.Combine(Path.GetTempPath(), "pfr-decoy-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(projectDir);
+            Directory.CreateDirectory(otherDir);
+            var savedCwd = Directory.GetCurrentDirectory();
+
+            try
+            {
+                // Multiprocess mode: CWD == projectDir
+                Directory.SetCurrentDirectory(projectDir);
+                var (result1, engine1) = RunTask(projectDir);
+
+                // Multithreaded mode: CWD == otherDir
+                Directory.SetCurrentDirectory(otherDir);
+                var (result2, engine2) = RunTask(projectDir);
+
+                // Both should produce the same result
+                result1.Should().Be(result2,
+                    "task should return the same result regardless of CWD");
+                engine1.Errors.Count.Should().Be(engine2.Errors.Count,
+                    "error count should match between multiprocess and multithreaded modes");
+                engine1.Warnings.Count.Should().Be(engine2.Warnings.Count,
+                    "warning count should match between multiprocess and multithreaded modes");
+            }
+            finally
+            {
+                Directory.SetCurrentDirectory(savedCwd);
+                Directory.Delete(projectDir, true);
+                if (Directory.Exists(otherDir)) Directory.Delete(otherDir, true);
+            }
+        }
+
+        [Theory]
+        [InlineData(4)]
+        [InlineData(16)]
+        public async System.Threading.Tasks.Task ProcessFrameworkReferences_ConcurrentExecution(int parallelism)
+        {
+            var errors = new ConcurrentBag<string>();
+            using var startGate = new ManualResetEventSlim(false);
+            var tasks = new System.Threading.Tasks.Task[parallelism];
+            for (int i = 0; i < parallelism; i++)
+            {
+                int idx = i;
+                tasks[idx] = System.Threading.Tasks.Task.Run(() =>
+            {
+                try
+                {
+                    var task = new ProcessFrameworkReferences
+                    {
+                        BuildEngine = new MockBuildEngine(),
+                        TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
+                        TargetFrameworkVersion = "8.0",
+                        TargetingPackRoot = "",
+                        RuntimeGraphPath = "",
+                        FrameworkReferences = Array.Empty<ITaskItem>(),
+                        KnownFrameworkReferences = Array.Empty<ITaskItem>(),
+                        KnownRuntimePacks = Array.Empty<ITaskItem>(),
+                        KnownCrossgen2Packs = Array.Empty<ITaskItem>(),
+                        KnownILCompilerPacks = Array.Empty<ITaskItem>(),
+                        KnownILLinkPacks = Array.Empty<ITaskItem>(),
+                        KnownWebAssemblySdkPacks = Array.Empty<ITaskItem>(),
+                    };
+                    startGate.Wait();
+                    task.Execute();
+                }
+                catch (Exception ex) { errors.Add($"Thread {idx}: {ex.Message}"); }
+            });
+            }
+            startGate.Set();
+            await System.Threading.Tasks.Task.WhenAll(tasks);
+
+            errors.Should().BeEmpty();
+        }
+
+        private static (bool result, MockBuildEngine engine) RunTask(string projectDir)
+        {
+            var engine = new MockBuildEngine();
+            var task = new ProcessFrameworkReferences
+            {
+                BuildEngine = engine,
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(projectDir),
+                TargetFrameworkVersion = "8.0",
+                TargetingPackRoot = "",
+                RuntimeGraphPath = "",
+                FrameworkReferences = Array.Empty<ITaskItem>(),
+                KnownFrameworkReferences = Array.Empty<ITaskItem>(),
+                KnownRuntimePacks = Array.Empty<ITaskItem>(),
+                KnownCrossgen2Packs = Array.Empty<ITaskItem>(),
+                KnownILCompilerPacks = Array.Empty<ITaskItem>(),
+                KnownILLinkPacks = Array.Empty<ITaskItem>(),
+                KnownWebAssemblySdkPacks = Array.Empty<ITaskItem>(),
+            };
+
+            bool result;
+            try { result = task.Execute(); }
+            catch { result = false; }
+            return (result, engine);
+        }
+    }
+}

src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenAResolveFrameworkReferencesMultiThreading.cs

@@ -0,0 +1,94 @@
+// 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.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Build.Framework;
+using Xunit;
+
+namespace Microsoft.NET.Build.Tasks.UnitTests
+{
+    public class GivenAResolveFrameworkReferencesMultiThreading
+    {
+        [Fact]
+        public void EmptyInputs_DoesNotCrash()
+        {
+            var task = new ResolveFrameworkReferences
+            {
+                BuildEngine = new MockBuildEngine(),
+                FrameworkReferences = Array.Empty<ITaskItem>(),
+                ResolvedTargetingPacks = Array.Empty<ITaskItem>(),
+                ResolvedRuntimePacks = Array.Empty<ITaskItem>(),
+            };
+
+            var result = task.Execute();
+
+            result.Should().BeTrue("empty inputs should succeed with no output");
+            (task.ResolvedFrameworkReferences ?? Array.Empty<ITaskItem>()).Should().BeEmpty();
+        }
+
+        [Fact]
+        public void ResolvesFrameworkReferences_WithMatchingPacks()
+        {
+            var fwRef = new MockTaskItem("Microsoft.NETCore.App", new Dictionary<string, string>());
+
+            var targetingPack = new MockTaskItem("Microsoft.NETCore.App", new Dictionary<string, string>());
+            targetingPack.SetMetadata("FrameworkName", "Microsoft.NETCore.App");
+            targetingPack.SetMetadata("NuGetPackageVersion", "8.0.0");
+            targetingPack.SetMetadata("Path", @"C:\packs\targeting");
+
+            var runtimePack = new MockTaskItem("Microsoft.NETCore.App.Runtime.win-x64", new Dictionary<string, string>());
+            runtimePack.SetMetadata("FrameworkName", "Microsoft.NETCore.App");
+            runtimePack.SetMetadata("NuGetPackageVersion", "8.0.0");
+            runtimePack.SetMetadata("PackageDirectory", @"C:\packs\runtime");
+
+            var task = new ResolveFrameworkReferences
+            {
+                BuildEngine = new MockBuildEngine(),
+                FrameworkReferences = new ITaskItem[] { fwRef },
+                ResolvedTargetingPacks = new ITaskItem[] { targetingPack },
+                ResolvedRuntimePacks = new ITaskItem[] { runtimePack },
+            };
+
+            var result = task.Execute();
+
+            result.Should().BeTrue();
+            task.ResolvedFrameworkReferences.Should().NotBeEmpty();
+        }
+        [Theory]
+        [InlineData(4)]
+        [InlineData(16)]
+        public async System.Threading.Tasks.Task ResolveFrameworkReferences_ConcurrentExecution(int parallelism)
+        {
+            var errors = new ConcurrentBag<string>();
+            using var startGate = new ManualResetEventSlim(false);
+            var tasks = new System.Threading.Tasks.Task[parallelism];
+            for (int i = 0; i < parallelism; i++)
+            {
+                int idx = i;
+                tasks[idx] = System.Threading.Tasks.Task.Run(() =>
+            {
+                try
+                {
+                    var task = new ResolveFrameworkReferences
+                    {
+                        BuildEngine = new MockBuildEngine(),
+                        FrameworkReferences = Array.Empty<ITaskItem>(),
+                        ResolvedTargetingPacks = Array.Empty<ITaskItem>(),
+                        ResolvedRuntimePacks = Array.Empty<ITaskItem>(),
+                    };
+                    startGate.Wait();
+                    task.Execute();
+                }
+                catch (Exception ex) { errors.Add($"Thread {idx}: {ex.Message}"); }
+            });
+            }
+            startGate.Set();
+            await System.Threading.Tasks.Task.WhenAll(tasks);
+
+            errors.Should().BeEmpty();
+        }
+    }
+}