V1.1.0/worker flexibility

.github/CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# Contributing to `Classlibrary1`
+# Contributing to `BenchmarkDotNet Extensions by Codebelt`
 When contributing to this repository, please first discuss the change you wish to make via issue,
 email, or any other method with the owners of this repository before making a change.
 
@@ -48,5 +48,5 @@ That is, in pursuit of the items on the left we have found the items on the righ
 [Manifesto for Software Craftsmanship](https://manifesto.softwarecraftsmanship.org/) is the originator of this text.
 
 ## License
-By contributing to `ClassLibrary1`, you agree that your contributions will be licensed
+By contributing to `BenchmarkDotNet Extensions by Codebelt`, you agree that your contributions will be licensed
 under the MIT license.

.github/copilot-instructions.md

@@ -149,6 +149,37 @@ namespace Codebelt.Extensions.BenchmarkDotNet
 - Before overriding methods, verify that the method is virtual or abstract; this rule also applies to mocks.
 - Never mock IMarshaller; always use a new instance of JsonMarshaller.
 
+## 9. Avoid `InternalsVisibleTo` in Tests
+
+- **Do not** use `InternalsVisibleTo` to access internal types or members from test projects.
+- Prefer **indirect testing via public APIs** that depend on the internal implementation (public facades, public extension methods, or other public entry points).
+
+### Preferred Pattern
+
+**Pattern name:** Public Facade Testing (also referred to as *Public API Proxy Testing*)
+
+**Description:**  
+Internal classes and methods must be validated by exercising the public API that consumes them. Tests should assert observable behavior exposed by the public surface rather than targeting internal implementation details directly.
+
+### Example Mapping
+
+- **Internal helper:** `DelimitedString` (internal static class)  
+- **Public API:** `TestOutputHelperExtensions.WriteLines()` (public extension method)  
+- **Test strategy:** Write tests for `WriteLines()` and verify its public behavior. The internal call to `DelimitedString.Create()` is exercised implicitly.
+
+### Benefits
+
+- Avoids exposing internal types to test assemblies.
+- Ensures tests reflect real-world usage patterns.
+- Maintains strong encapsulation and a clean public API.
+- Tests remain resilient to internal refactoring as long as public behavior is preserved.
+
+### When to Apply
+
+- Internal logic is fully exercised through existing public APIs.
+- Public entry points provide sufficient coverage of internal code paths.
+- The internal implementation exists solely as a helper or utility for public-facing functionality.
+
 ---
 description: 'Writing Performance Tests in Codebelt.Extensions.BenchmarkDotNet'
 applyTo: "tuning/**, **/*Benchmark*.cs"

.nuget/Codebelt.Extensions.BenchmarkDotNet.Console/PackageReleaseNotes.txt

@@ -1,6 +1,17 @@
+Version: 1.1.0
+Availability: .NET 10 and .NET 9
+
+# ALM
+- CHANGED Dependencies have been upgraded to the latest compatible versions for all supported target frameworks (TFMs)
+
+# Improvements
+- EXTENDED BenchmarkProgram class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace to support an optional service configurator delegate for customizing the IServiceCollection during host building
+- EXTENDED BenchmarkWorker class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace to support skipping benchmarks that already have generated reports based on the BenchmarkWorkspaceOptions.SkipBenchmarksWithReports property
+- CHANGED BenchmarkWorker class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace to conditionally suppress console status messages in services based on whether you are in a debugging session or not
+
 Version: 1.0.0
 Availability: .NET 10 and .NET 9
-
+ 
 # New Features
 - ADDED BenchmarkContext class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace that represents the command-line context for a benchmark run
 - ADDED BenchmarkProgram class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace that provides the main entry point for hosting and running benchmarks using BenchmarkDotNet

.nuget/Codebelt.Extensions.BenchmarkDotNet/PackageReleaseNotes.txt

@@ -1,6 +1,19 @@
+Version: 1.1.0
+Availability: .NET 10 and .NET 9
+
+# ALM
+- CHANGED Dependencies have been upgraded to the latest compatible versions for all supported target frameworks (TFMs)
+
+# Bug Fixes
+- FIXED BenchmarkWorkspaceOptions class in the Codebelt.Extensions.BenchmarkDotNet namespace so it no longer relies on Danish culture
+
+# Improvements
+- EXTENDED BenchmarkWorkspace class in the Codebelt.Extensions.BenchmarkDotNet namespace with two new static methods; GetReportsResultsPath and GetReportsTuningPath for retrieving the paths to the reports results and tuning directories respectively
+- EXTENDED BenchmarkWorkspaceOptions class in the Codebelt.Extensions.BenchmarkDotNet namespace to include one new property; SkipBenchmarksWithReports that indicates whether benchmarks that already have generated reports should be skipped during execution
+
 Version: 1.0.0
 Availability: .NET 10 and .NET 9
-
+ 
 # New Features
 - ADDED BenchmarkWorkspace class in the Codebelt.Extensions.BenchmarkDotNet namespace that provides a default implementation of IBenchmarkWorkspace for discovering and handling assemblies and their generated artifacts in BenchmarkDotNet
 - ADDED BenchmarkWorkspaceOptions class in the Codebelt.Extensions.BenchmarkDotNet namespace that specifies configuration options that is related to the BenchmarkWorkspace class

CHANGELOG.md

@@ -4,6 +4,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 For more details, please refer to `PackageReleaseNotes.txt` on a per assembly basis in the `.nuget` folder.
 
+## [1.1.0] - 2025-12-14
+
+### Changed
+
+- `BenchmarkWorkspace` class in the Codebelt.Extensions.BenchmarkDotNet namespace was extended with two new static methods; `GetReportsResultsPath` and `GetReportsTuningPath` for retrieving the paths to the reports results and tuning directories respectively,
+- `BenchmarkWorkspaceOptions` class in the Codebelt.Extensions.BenchmarkDotNet namespace was extended with an additional new property; `SkipBenchmarksWithReports` that indicates whether benchmarks that already have generated reports should be skipped during execution,
+- `BenchmarkProgram` class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace was extended to support an optional service configurator delegate for customizing the `IServiceCollection` during host building,
+- `BenchmarkWorker` class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace was extended to support skipping benchmarks that already have generated reports based on the `BenchmarkWorkspaceOptions.SkipBenchmarksWithReports` property,
+- `BenchmarkWorker` class in the Codebelt.Extensions.BenchmarkDotNet.Console namespace was changed to conditionally suppress console status messages in services based on whether you are in a debugging session or not.
+
+### Fixed
+
+- `BenchmarkWorkspaceOptions` class in the Codebelt.Extensions.BenchmarkDotNet namespace was fixed so it no longer relies on Danish culture.
+
 ## [1.0.0] - 2025-12-12
 
 This is the initial stable release of the `Codebelt.Extensions.BenchmarkDotNet` and `Codebelt.Extensions.BenchmarkDotNet.Console` packages.

Directory.Build.props

@@ -6,7 +6,7 @@
     <IsToolingProject>$(MSBuildProjectDirectory.ToLower().StartsWith('$(MSBuildThisFileDirectory.ToLower())tooling'))</IsToolingProject>
     <IsLinux>$([MSBuild]::IsOSPlatform('Linux'))</IsLinux>
     <IsWindows>$([MSBuild]::IsOSPlatform('Windows'))</IsWindows>
-    <IsMainAuthor Condition="'$(EMAIL)' == 'classlibrary1@dot.net'">true</IsMainAuthor>
+    <IsMainAuthor Condition="'$(EMAIL)' == 'michael@geekle.io'">true</IsMainAuthor>
     <SkipSignAssembly>false</SkipSignAssembly>
     <PackageReleaseNotesFile>..\..\.nuget\$(MSBuildProjectName)\PackageReleaseNotes.txt</PackageReleaseNotesFile>
     <LangVersion>latest</LangVersion>

Directory.Packages.props

@@ -7,7 +7,7 @@
     <PackageVersion Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.15.8" />
     <PackageVersion Include="Codebelt.Bootstrapper.Console" Version="5.0.1" />
     <PackageVersion Include="Codebelt.Extensions.Xunit.App" Version="11.0.2" />
-    <PackageVersion Include="Cuemon.Core" Version="10.1.0" />
+    <PackageVersion Include="Cuemon.Core" Version="10.1.1" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="MinVer" Version="6.0.0" />
     <PackageVersion Include="coverlet.collector" Version="6.0.4" />

src/Codebelt.Extensions.BenchmarkDotNet.Console/BenchmarkProgram.cs

@@ -43,7 +43,21 @@ static BenchmarkProgram()
         /// </remarks>
         public static void Run(string[] args, Action<BenchmarkWorkspaceOptions> setup = null)
         {
-            Run<BenchmarkWorkspace>(args, setup);
+            Run(args, null, setup);
+        }
+
+        /// <summary>
+        /// Runs benchmarks using the default <see cref="BenchmarkWorkspace"/> implementation.
+        /// </summary>
+        /// <param name="args">The command-line arguments passed to the application.</param>
+        /// <param name="serviceConfigurator">The delegate that will be invoked to configure additional services in the <see cref="IServiceCollection"/>.</param>
+        /// <param name="setup">The <see cref="BenchmarkWorkspaceOptions"/> which may be configured.</param>
+        /// <remarks>
+        /// This method configures the host builder with the necessary services, builds the host, and runs it to execute benchmarks.
+        /// </remarks>
+        public static void Run(string[] args, Action<IServiceCollection> serviceConfigurator = null, Action<BenchmarkWorkspaceOptions> setup = null)
+        {
+            Run<BenchmarkWorkspace>(args, serviceConfigurator, setup);
         }
 
         /// <summary>
@@ -56,14 +70,30 @@ public static void Run(string[] args, Action<BenchmarkWorkspaceOptions> setup =
         /// This method configures the host builder with the necessary services, builds the host, and runs it to execute benchmarks.
         /// </remarks>
         public static void Run<TWorkspace>(string[] args, Action<BenchmarkWorkspaceOptions> setup = null) where TWorkspace : class, IBenchmarkWorkspace
+        {
+            Run<TWorkspace>(args, null, setup);
+        }
+
+        /// <summary>
+        /// Runs benchmarks using a custom implementation of <see cref="IBenchmarkWorkspace"/>.
+        /// </summary>
+        /// <typeparam name="TWorkspace">The type of the workspace that implements <see cref="IBenchmarkWorkspace"/>.</typeparam>
+        /// <param name="args">The command-line arguments passed to the application.</param>
+        /// <param name="serviceConfigurator">The delegate that will be invoked to configure additional services in the <see cref="IServiceCollection"/>.</param>
+        /// <param name="setup">The <see cref="BenchmarkWorkspaceOptions"/> which may be configured.</param>
+        /// <remarks>
+        /// This method configures the host builder with the necessary services, builds the host, and runs it to execute benchmarks.
+        /// </remarks>
+        public static void Run<TWorkspace>(string[] args, Action<IServiceCollection> serviceConfigurator = null, Action<BenchmarkWorkspaceOptions> setup = null) where TWorkspace : class, IBenchmarkWorkspace
         {
             var hostBuilder = CreateHostBuilder(args);
             hostBuilder.ConfigureServices(services =>
             {
                 services.AddSingleton(new BenchmarkContext(args));
                 services.AddBenchmarkWorkspace<TWorkspace>(setup);
+                serviceConfigurator?.Invoke(services);
             });
-            var host = hostBuilder.Build();
+            using var host = hostBuilder.Build();
             host.Run();
         }
     }

src/Codebelt.Extensions.BenchmarkDotNet.Console/BenchmarkWorker.cs

@@ -4,8 +4,12 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using System;
+using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Filters;
 
 namespace Codebelt.Extensions.BenchmarkDotNet.Console
 {
@@ -33,7 +37,7 @@
         /// </remarks>
         public override void ConfigureServices(IServiceCollection services)
         {
-            services.Configure<ConsoleLifetimeOptions>(o => o.SuppressStatusMessages = true);
+            services.Configure<ConsoleLifetimeOptions>(o => o.SuppressStatusMessages = !BenchmarkProgram.IsDebugBuild);
         }
 
         /// <summary>
@@ -46,13 +50,41 @@
         /// When arguments are provided, they are forwarded to <see cref="BenchmarkSwitcher"/> for selective execution.
         /// After execution completes, the worker performs artifact post-processing.
         /// </remarks>
         public override Task RunAsync(IServiceProvider serviceProvider, CancellationToken cancellationToken)
         {
             var options = serviceProvider.GetRequiredService<BenchmarkWorkspaceOptions>();
             var workspace = serviceProvider.GetRequiredService<IBenchmarkWorkspace>();
             var assemblies = workspace.LoadBenchmarkAssemblies();
             var context = serviceProvider.GetRequiredService<BenchmarkContext>();
 
+            if (options.SkipBenchmarksWithReports)
+            {
+                var benchmarkTypes = assemblies.SelectMany(a => a.GetTypes().Where(t => t.Name.EndsWith("Benchmark", StringComparison.Ordinal))).ToList();
+                options.ConfigureBenchmarkDotNet(c =>
+                {
+                    var tuningPath = BenchmarkWorkspace.GetReportsTuningPath(options);
+                    if (!Directory.Exists(tuningPath)) { return c; }
+                    var reports = Directory.EnumerateFiles(tuningPath);
+                    foreach (var report in reports)
+                    {
+                        var filename = Path.GetFileNameWithoutExtension(report);
+                        var potentialTypeFullName = filename.Split('-').FirstOrDefault();
+                        if (string.IsNullOrWhiteSpace(potentialTypeFullName)) { continue; }
+
+                        var potentialTypeName = potentialTypeFullName.Split('.').LastOrDefault();
+                        if (string.IsNullOrWhiteSpace(potentialTypeName)) { continue; }
+
+                        var matchingType = benchmarkTypes.FirstOrDefault(t => t.Name.Equals(potentialTypeName, StringComparison.OrdinalIgnoreCase));
+
+                        if (matchingType != null)
+                        {
+                            c = c.AddFilter(new SimpleFilter(bc => bc.Descriptor.Type != matchingType));
+                        }
+                    }
+                    return c;
+                });
+            }
+
             try
             {
                 if (context.Args.Length == 0)

src/Codebelt.Extensions.BenchmarkDotNet/BenchmarkWorkspace.cs

@@ -21,6 +21,34 @@
     private static readonly Lock AssemblyResolverLock = new();
     private static Dictionary<string, string> _assemblyLookup = new(StringComparer.OrdinalIgnoreCase);
 
+    /// <summary>
+    /// Gets the path to the BenchmarkDotNet results directory
+    /// </summary>
+    /// <param name="options">The <see cref="BenchmarkWorkspaceOptions"/> which configures repository paths, build modes and BenchmarkDotNet configuration.</param>
+    /// <returns>A string containing the full path to the 'results' directory within the artifacts path.</returns>
+    /// <remarks>
+    /// This path is constructed from the configured <see cref="IConfig.ArtifactsPath"/> and the "results" subdirectory.
+    /// </remarks>
+    public static string GetReportsResultsPath(BenchmarkWorkspaceOptions options)
+    {
+        Validator.ThrowIfInvalidOptions(options);
+        return Path.Combine(options.Configuration.ArtifactsPath, "results");
+    }
+
+    /// <summary>
+    /// Gets the path to the tuning folder where final benchmark reports are stored.
+    /// </summary>
+    /// <param name="options">The <see cref="BenchmarkWorkspaceOptions"/> which configures repository paths, build modes and BenchmarkDotNet configuration.</param>
+    /// <returns>A string representing the full path to the tuning reports directory.</returns>
+    /// <remarks>
+    /// This path is constructed from the configured <see cref="IConfig.ArtifactsPath"/> and the <see cref="BenchmarkWorkspaceOptions.RepositoryTuningFolder"/>.
+    /// </remarks>
+    public static string GetReportsTuningPath(BenchmarkWorkspaceOptions options)
+    {
+        Validator.ThrowIfInvalidOptions(options);
+        return Path.Combine(options.Configuration.ArtifactsPath, options.RepositoryTuningFolder);
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="BenchmarkWorkspace"/> class with the specified options.
     /// </summary>
@@ -74,12 +102,10 @@
     /// </remarks>
     public void PostProcessArtifacts()
     {
-        var reportsResultsPath = Path.Combine(_options.Configuration.ArtifactsPath, "results");
-        var reportsTuningPath = Path.Combine(_options.Configuration.ArtifactsPath, _options.RepositoryTuningFolder);
-        CleanupResults(reportsResultsPath, reportsTuningPath);
+        CleanupResults(GetReportsResultsPath(_options), GetReportsTuningPath(_options));
     }
 
     private static IEnumerable<Assembly> LoadAssemblies(string repositoryPath, string targetFrameworkMoniker, string benchmarkProjectSuffix, string repositoryTuningFolder, bool useDebugBuild)
     {
         var tuningDir = Path.Combine(repositoryPath, repositoryTuningFolder);
         Directory.CreateDirectory(tuningDir);
@@ -95,7 +121,7 @@
 
         var candidatePaths = Directory
             .EnumerateFiles(tuningDir, $"*.{benchmarkProjectSuffix}.dll", SearchOption.AllDirectories)
             .Where(path => path.IndexOf(buildSegment, StringComparison.OrdinalIgnoreCase) >= 0);
 
         foreach (var path in candidatePaths)
         {
@@ -116,7 +142,7 @@
                     continue;
                 }
 
                 assemblies.Add(Assembly.LoadFrom(path));
             }
             catch
             {
@@ -188,11 +214,10 @@
 
         Directory.CreateDirectory(reportsTuningPath);
 
-        foreach (var file in Directory.GetFiles(reportsResultsPath).Where(s => !s.EndsWith(".lock")))
+        foreach (var file in Directory.GetFiles(reportsResultsPath).Where(f => !Path.GetFileNameWithoutExtension(f).StartsWith("BenchmarkRun", StringComparison.Ordinal)))
         {
             var targetFile = Path.Combine(reportsTuningPath, Path.GetFileName(file));
-            File.Delete(targetFile);
-            File.Move(file, targetFile);
+            File.Move(file, targetFile, true);
         }
 
         Directory.Delete(reportsResultsPath, recursive: true);