cache repeated accesses

Author: baronfel

src/Cli/dotnet/Commands/Test/TestCommandParser.cs

@@ -5,6 +5,8 @@
 using System.Diagnostics;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.Extensions.Configuration;
+using Microsoft.DotNet.Cli.Configuration;
+using Microsoft.Extensions.Configuration.DotnetCli.Services;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
@@ -166,48 +168,8 @@ public static Command GetCommand()
 
     public static string GetTestRunnerName()
     {
-        var builder = new ConfigurationBuilder();
-
-        string? dotnetConfigPath = GetDotnetConfigPath(Environment.CurrentDirectory);
-        if (!File.Exists(dotnetConfigPath))
-        {
-            return CliConstants.VSTest;
-        }
-
-        builder.AddIniFile(dotnetConfigPath);
-
-        IConfigurationRoot config = builder.Build();
-        var testSection = config.GetSection("dotnet.test.runner");
-
-        if (!testSection.Exists())
-        {
-            return CliConstants.VSTest;
-        }
-
-        string? runnerNameSection = testSection["name"];
-
-        if (string.IsNullOrEmpty(runnerNameSection))
-        {
-            return CliConstants.VSTest;
-        }
-
-        return runnerNameSection;
-    }
-
-    private static string? GetDotnetConfigPath(string? startDir)
-    {
-        string? directory = startDir;
-        while (directory != null)
-        {
-            string dotnetConfigPath = Path.Combine(directory, "dotnet.config");
-            if (File.Exists(dotnetConfigPath))
-            {
-                return dotnetConfigPath;
-            }
-
-            directory = Path.GetDirectoryName(directory);
-        }
-        return null;
+        var configurationService = DotNetConfigurationFactory.Create();
+        return configurationService.Test.RunnerName;
     }
 
     private static Command ConstructCommand()

src/Cli/dotnet/Configuration/DotNetConfigurationFactory.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Configuration.DotnetCli.Models;
 using Microsoft.Extensions.Configuration.DotnetCli.Providers;
 using Microsoft.Extensions.Configuration;
+using System.Collections.Concurrent;
 using System.IO;
 
 namespace Microsoft.DotNet.Cli.Configuration
@@ -15,14 +16,44 @@ namespace Microsoft.DotNet.Cli.Configuration
     /// </summary>
     public static class DotNetConfigurationFactory
     {
+        // Cache for the default configuration service instance
+        private static readonly Lazy<IDotNetConfigurationService> _defaultInstance = new(() => CreateInternal(null), LazyThreadSafetyMode.ExecutionAndPublication);
+        
+        // Cache for configuration services by working directory
+        private static readonly ConcurrentDictionary<string, Lazy<IDotNetConfigurationService>> _instancesByDirectory = new();
+
         /// <summary>
         /// Creates and configures the .NET CLI configuration service with default providers.
         /// This method follows the layered configuration approach: environment variables override global.json,
         /// and configuration is loaded lazily for performance.
+        /// Results are cached to avoid repeated expensive configuration building.
         /// </summary>
         /// <param name="workingDirectory">The working directory to search for global.json files. Defaults to current directory.</param>
         /// <returns>A configured IDotNetConfigurationService instance</returns>
         public static IDotNetConfigurationService Create(string? workingDirectory = null)
+        {
+            if (workingDirectory == null)
+            {
+                // Use the default cached instance for null working directory
+                return _defaultInstance.Value;
+            }
+
+            // Normalize the working directory path for consistent caching
+            var normalizedPath = Path.GetFullPath(workingDirectory);
+            
+            // Get or create a cached instance for this specific working directory
+            var lazyInstance = _instancesByDirectory.GetOrAdd(normalizedPath, 
+                path => new Lazy<IDotNetConfigurationService>(() => CreateInternal(path), LazyThreadSafetyMode.ExecutionAndPublication));
+            
+            return lazyInstance.Value;
+        }
+
+        /// <summary>
+        /// Internal method that performs the actual configuration creation without caching.
+        /// </summary>
+        /// <param name="workingDirectory">The working directory to search for configuration files.</param>
+        /// <returns>A configured IDotNetConfigurationService instance</returns>
+        private static IDotNetConfigurationService CreateInternal(string? workingDirectory)
         {
             workingDirectory ??= Directory.GetCurrentDirectory();
 
@@ -31,10 +62,13 @@ public static IDotNetConfigurationService Create(string? workingDirectory = null
             // Configuration sources are added in reverse precedence order
             // Last added has highest precedence
 
-            // 1. global.json (custom provider with key mapping) - lowest precedence
+            // 1. dotnet.config (custom provider with key mapping) - lowest precedence  
+            configurationBuilder.Add(new DotNetConfigurationSource(workingDirectory));
+
+            // 2. global.json (custom provider with key mapping) - medium precedence
             configurationBuilder.Add(new GlobalJsonConfigurationSource(workingDirectory));
 
-            // 2. Environment variables (custom provider with key mapping) - highest precedence
+            // 3. Environment variables (custom provider with key mapping) - highest precedence
             configurationBuilder.Add(new DotNetEnvironmentConfigurationSource());
 
             var configuration = configurationBuilder.Build();

src/Microsoft.Extensions.Configuration.DotnetCli/Models/TestConfiguration.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.
+
+namespace Microsoft.Extensions.Configuration.DotnetCli.Models;
+
+/// <summary>
+/// Configuration settings that control test runner behavior.
+/// </summary>
+public sealed class TestConfiguration
+{
+    /// <summary>
+    /// Gets or sets the test runner name to use.
+    /// Mapped from dotnet.config file: [dotnet.test.runner] name=VALUE
+    /// Defaults to "VSTest" if not specified.
+    /// </summary>
+    public string RunnerName { get; set; } = "VSTest";
+}

src/Microsoft.Extensions.Configuration.DotnetCli/Providers/DotNetConfigurationProvider.cs

@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Configuration.Ini;
+
+namespace Microsoft.Extensions.Configuration.DotnetCli.Providers;
+
+/// <summary>
+/// Configuration provider for dotnet.config INI files with key mapping.
+/// Maps dotnet.config keys to the expected configuration structure.
+/// </summary>
+public class DotNetConfigurationProvider : IniConfigurationProvider
+{
+    private static readonly Dictionary<string, string> KeyMappings = new(StringComparer.OrdinalIgnoreCase)
+    {
+        // Map INI section:key to expected configuration path
+        ["dotnet.test.runner:name"] = "Test:RunnerName",
+        
+        // Future mappings can be added here for other dotnet.config settings
+        // ["dotnet.example.section:key"] = "ConfigSection:Property",
+    };
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DotNetConfigurationProvider"/> class.
+    /// </summary>
+    /// <param name="source">The configuration source.</param>
+    public DotNetConfigurationProvider(DotNetConfigurationSource source) : base(source)
+    {
+    }
+
+    /// <summary>
+    /// Loads configuration data with key transformation.
+    /// </summary>
+    public override void Load()
+    {
+        // Load the INI file normally first
+        base.Load();
+
+        // Transform keys according to our mapping
+        var transformedData = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var kvp in Data)
+        {
+            string key = kvp.Key;
+            string? value = kvp.Value;
+
+            // Check if we have a mapping for this key
+            if (KeyMappings.TryGetValue(key, out string? mappedKey))
+            {
+                transformedData[mappedKey] = value;
+            }
+            else
+            {
+                // Keep unmapped keys as-is
+                transformedData[key] = value;
+            }
+        }
+
+        // Replace the data with transformed keys
+        Data = transformedData;
+    }
+}

src/Microsoft.Extensions.Configuration.DotnetCli/Providers/DotNetConfigurationSource.cs

@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Configuration.Ini;
+
+namespace Microsoft.Extensions.Configuration.DotnetCli.Providers;
+
+/// <summary>
+/// Configuration source for dotnet.config INI files with key mapping.
+/// </summary>
+public class DotNetConfigurationSource : IniConfigurationSource
+{
+    public DotNetConfigurationSource(string workingDirectory)
+    {
+        Path = FindDotNetConfigPath(workingDirectory);
+        Optional = true; // Make it optional since dotnet.config may not exist
+    }
+    /// <summary>
+    /// Builds the configuration provider for dotnet.config files.
+    /// </summary>
+    /// <param name="builder">The configuration builder.</param>
+    /// <returns>The configuration provider.</returns>
+    public override IConfigurationProvider Build(IConfigurationBuilder builder)
+    {
+        EnsureDefaults(builder);
+        return new DotNetConfigurationProvider(this);
+    }
+
+    private static string FindDotNetConfigPath(string? workingDirectory = null)
+    {
+        string? directory = workingDirectory ?? Directory.GetCurrentDirectory();
+        // Search for dotnet.config in the current directory and upwards
+        while (directory != null)
+        {
+            string dotnetConfigPath = System.IO.Path.Combine(directory, "dotnet.config");
+            if (File.Exists(dotnetConfigPath))
+            {
+                return dotnetConfigPath;
+            }
+
+            directory = System.IO.Path.GetDirectoryName(directory);
+        }
+        return "dotnet.config"; // Return default path even if not found
+    }
+}

src/Microsoft.Extensions.Configuration.DotnetCli/Services/DotNetConfiguration.cs

@@ -27,12 +27,8 @@ public static IConfiguration Create(string? workingDirectory = null)
 
         workingDirectory ??= Directory.GetCurrentDirectory();
 
-        // Add dotnet.config if it exists (future enhancement)
-        var dotnetConfigPath = Path.Combine(workingDirectory, "dotnet.config");
-        if (File.Exists(dotnetConfigPath))
-        {
-            builder.AddIniFile(dotnetConfigPath, optional: true, reloadOnChange: false);
-        }
+        // Add dotnet.config with custom key mapping
+        builder.Add(new DotNetConfigurationSource(workingDirectory));
 
         // Add global.json with a custom configuration provider that maps keys
         builder.Add(new GlobalJsonConfigurationSource(workingDirectory));

src/Microsoft.Extensions.Configuration.DotnetCli/Services/DotNetConfigurationService.cs

@@ -22,6 +22,7 @@ public class DotNetConfigurationService : IDotNetConfigurationService
     private readonly Lazy<DevelopmentConfiguration> _development;
     private readonly Lazy<ToolConfiguration> _tool;
     private readonly Lazy<NuGetConfiguration> _nuget;
+    private readonly Lazy<TestConfiguration> _test;
 
     public IConfiguration RawConfiguration => _configuration;
 
@@ -35,6 +36,7 @@ public class DotNetConfigurationService : IDotNetConfigurationService
     public DevelopmentConfiguration Development => _development.Value;
     public ToolConfiguration Tool => _tool.Value;
     public NuGetConfiguration NuGet => _nuget.Value;
+    public TestConfiguration Test => _test.Value;
 
     public DotNetConfigurationService(IConfiguration configuration)
     {
@@ -59,5 +61,7 @@ public DotNetConfigurationService(IConfiguration configuration)
             _configuration.GetSection("Tool").Get<ToolConfiguration>() ?? new());
         _nuget = new Lazy<NuGetConfiguration>(() =>
             _configuration.GetSection("NuGet").Get<NuGetConfiguration>() ?? new());
+        _test = new Lazy<TestConfiguration>(() =>
+            _configuration.GetSection("Test").Get<TestConfiguration>() ?? new());
     }
 }

src/Microsoft.Extensions.Configuration.DotnetCli/Services/IDotNetConfigurationService.cs

@@ -59,4 +59,9 @@ public interface IDotNetConfigurationService
     /// Gets NuGet package management configuration settings.
     /// </summary>
     NuGetConfiguration NuGet { get; }
+
+    /// <summary>
+    /// Gets test runner configuration settings.
+    /// </summary>
+    TestConfiguration Test { get; }
 }