Get TargetFrameworkAttribute from the benchmark assembly.

timcassell · timcassell · commit c62caa622917 · 2025-11-09T03:22:01.000-05:00
diff --git a/src/BenchmarkDotNet/Environments/Runtimes/ClrRuntime.cs b/src/BenchmarkDotNet/Environments/Runtimes/ClrRuntime.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Reflection;
 using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
@@ -15,14 +16,6 @@ public class ClrRuntime : Runtime, IEquatable<ClrRuntime>
         public static readonly ClrRuntime Net48 = new ClrRuntime(RuntimeMoniker.Net48, "net48", ".NET Framework 4.8");
         public static readonly ClrRuntime Net481 = new ClrRuntime(RuntimeMoniker.Net481, "net481", ".NET Framework 4.8.1");
 
-        // Use Lazy to avoid any assembly loading issues on non Windows systems, and for fast cached access for multiple reads.
-        // Also so that the value will be obtained from the first call which happens on the user's thread,
-        // then when this is read again on a background thread from the BuildInParallel step, it will return the cached result.
-#if NET6_0_OR_GREATER
-        [System.Runtime.Versioning.SupportedOSPlatform("windows")]
-#endif
-        private static readonly Lazy<ClrRuntime> Current = new(RetrieveCurrentVersion, true);
-
         public string Version { get; }
 
         private ClrRuntime(RuntimeMoniker runtimeMoniker, string msBuildMoniker, string displayName, string? version = null)
@@ -57,21 +50,28 @@ internal static ClrRuntime GetCurrentVersion()
                 throw new PlatformNotSupportedException(".NET Framework supports Windows OS only.");
             }
 
-            return Current.Value;
+            string version = FrameworkVersionHelper.GetLatestNetDeveloperPackVersion()
+                ?? FrameworkVersionHelper.GetFrameworkReleaseVersion(); // .NET Developer Pack is not installed
+            return GetRuntimeFromVersion(version);
         }
 
-#if NET6_0_OR_GREATER
-        [System.Runtime.Versioning.SupportedOSPlatform("windows")]
-#endif
-        private static ClrRuntime RetrieveCurrentVersion()
+        internal static ClrRuntime GetTargetOrCurrentVersion(Assembly? assembly)
         {
-            // Try to determine the Framework version that the executable was compiled for.
-            string version = FrameworkVersionHelper.GetTargetFrameworkVersion()
+            if (!OsDetector.IsWindows())
+            {
+                throw new PlatformNotSupportedException(".NET Framework supports Windows OS only.");
+            }
+
+            // Try to determine the Framework version that the assembly was compiled for.
+            string? version = FrameworkVersionHelper.GetTargetFrameworkVersion(assembly);
+            return version != null
+                ? GetRuntimeFromVersion(version)
                 // Fallback to the current running Framework version.
-                ?? FrameworkVersionHelper.GetLatestNetDeveloperPackVersion()
-                ?? FrameworkVersionHelper.GetFrameworkReleaseVersion(); // .NET Developer Pack is not installed
+                : GetCurrentVersion();
+        }
 
-            return version switch
+        private static ClrRuntime GetRuntimeFromVersion(string version)
+            => version switch
             {
                 "4.6.1" => Net461,
                 "4.6.2" => Net462,
@@ -83,6 +83,5 @@ private static ClrRuntime RetrieveCurrentVersion()
                 // unlikely to happen but theoretically possible
                 _ => new ClrRuntime(RuntimeMoniker.NotRecognized, $"net{version.Replace(".", null)}", $".NET Framework {version}"),
             };
-        }
     }
 }
diff --git a/src/BenchmarkDotNet/Helpers/FrameworkVersionHelper.cs b/src/BenchmarkDotNet/Helpers/FrameworkVersionHelper.cs
@@ -1,6 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -24,54 +22,25 @@ private static readonly (int minReleaseNumber, string version)[] FrameworkVersio
             (394254, "4.6.1")
         ];
 
-        internal static string? GetTargetFrameworkVersion()
+        internal static string? GetTargetFrameworkVersion(Assembly? assembly)
         {
-            // Search assemblies until we find a TargetFrameworkAttribute with a supported Framework version.
-            // We don't search all assemblies, only the entry assembly and callers.
-            foreach (var assembly in EnumerateAssemblies())
+            // Look for a TargetFrameworkAttribute with a supported Framework version.
+            foreach (var attribute in assembly.GetCustomAttributes<TargetFrameworkAttribute>())
             {
-                foreach (var attribute in assembly.GetCustomAttributes<TargetFrameworkAttribute>())
+                switch (attribute.FrameworkName)
                 {
-                    switch (attribute.FrameworkName)
-                    {
-                        case ".NETFramework,Version=v4.6.1": return "4.6.1";
-                        case ".NETFramework,Version=v4.6.2": return "4.6.2";
-                        case ".NETFramework,Version=v4.7": return "4.7";
-                        case ".NETFramework,Version=v4.7.1": return "4.7.1";
-                        case ".NETFramework,Version=v4.7.2": return "4.7.2";
-                        case ".NETFramework,Version=v4.8": return "4.8";
-                        case ".NETFramework,Version=v4.8.1": return "4.8.1";
-                    }
+                    case ".NETFramework,Version=v4.6.1": return "4.6.1";
+                    case ".NETFramework,Version=v4.6.2": return "4.6.2";
+                    case ".NETFramework,Version=v4.7": return "4.7";
+                    case ".NETFramework,Version=v4.7.1": return "4.7.1";
+                    case ".NETFramework,Version=v4.7.2": return "4.7.2";
+                    case ".NETFramework,Version=v4.8": return "4.8";
+                    case ".NETFramework,Version=v4.8.1": return "4.8.1";
                 }
             }
 
+            // TargetFrameworkAttribute not found, or the assembly targeted a version older than we support.
             return null;
-
-            static IEnumerable<Assembly> EnumerateAssemblies()
-            {
-                var entryAssembly = Assembly.GetEntryAssembly();
-                // Assembly.GetEntryAssembly() returns null in unit test frameworks.
-                if (entryAssembly != null)
-                {
-                    yield return entryAssembly;
-                }
-                // Search calling assemblies starting from the highest stack frame
-                // (expected to be the entry assembly if Assembly.GetEntryAssembly() returned null),
-                // excluding this assembly.
-                var stacktrace = new StackTrace(false);
-                var searchedAssemblies = new HashSet<Assembly>()
-                {
-                    stacktrace.GetFrame(0).GetMethod().ReflectedType.Assembly
-                };
-                for (int i = stacktrace.FrameCount - 1; i >= 1 ; --i)
-                {
-                    var assembly = stacktrace.GetFrame(i).GetMethod().ReflectedType.Assembly;
-                    if (searchedAssemblies.Add(assembly))
-                    {
-                        yield return assembly;
-                    }
-                }
-            }
         }
 
         internal static string GetFrameworkDescription()
diff --git a/src/BenchmarkDotNet/Portability/RuntimeInformation.cs b/src/BenchmarkDotNet/Portability/RuntimeInformation.cs
@@ -182,6 +182,11 @@ string GetDetailedVersion()
             }
         }
 
+        internal static Runtime GetTargetOrCurrentRuntime(Assembly? assembly)
+            => !IsMono && !IsWasm && IsFullFramework // Match order of checks in GetCurrentRuntime().
+                ? ClrRuntime.GetTargetOrCurrentVersion(assembly)
+                : GetCurrentRuntime();
+
         internal static Runtime GetCurrentRuntime()
         {
             //do not change the order of conditions because it may cause incorrect determination of runtime
diff --git a/src/BenchmarkDotNet/Running/BenchmarkCase.cs b/src/BenchmarkDotNet/Running/BenchmarkCase.cs
@@ -30,7 +30,7 @@ internal BenchmarkCase(Descriptor descriptor, Job job, ParameterInstances parame
 
         public Runtime GetRuntime() => Job.Environment.HasValue(EnvironmentMode.RuntimeCharacteristic)
                 ? Job.Environment.Runtime
-                : RuntimeInformation.GetCurrentRuntime();
+                : RuntimeInformation.GetTargetOrCurrentRuntime(Descriptor.WorkloadMethod.DeclaringType.Assembly);
 
         public void Dispose() => Parameters.Dispose();
 
diff --git a/src/BenchmarkDotNet/Running/BenchmarkPartitioner.cs b/src/BenchmarkDotNet/Running/BenchmarkPartitioner.cs
@@ -2,9 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNet.Characteristics;
-using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Toolchains;
 
 namespace BenchmarkDotNet.Running
@@ -22,18 +20,16 @@ internal class BenchmarkRuntimePropertiesComparer : IEqualityComparer<BenchmarkC
         {
             internal static readonly IEqualityComparer<BenchmarkCase> Instance = new BenchmarkRuntimePropertiesComparer();
 
-            private static readonly Runtime Current = RuntimeInformation.GetCurrentRuntime();
-
             public bool Equals(BenchmarkCase x, BenchmarkCase y)
             {
-                if (x == null && y == null)
+                if (x == y)
                     return true;
                 if (x == null || y == null)
                     return false;
                 var jobX = x.Job;
                 var jobY = y.Job;
 
-                if (AreDifferent(GetRuntime(jobX), GetRuntime(jobY))) // Mono vs .NET vs Core
+                if (AreDifferent(x.GetRuntime(), x.GetRuntime())) // Mono vs .NET vs Core
                     return false;
                 if (AreDifferent(x.GetToolchain(), y.GetToolchain())) // Mono vs .NET vs Core vs InProcess
                     return false;
@@ -90,20 +86,8 @@ public int GetHashCode(BenchmarkCase obj)
                 return hashCode.ToHashCode();
             }
 
-            private static Runtime GetRuntime(Job job)
-                => job.Environment.HasValue(EnvironmentMode.RuntimeCharacteristic)
-                    ? job.Environment.Runtime
-                    : Current;
-
             private static bool AreDifferent(object x, object y)
-            {
-                if (x == null && y == null)
-                    return false;
-                if (x == null || y == null)
-                    return true;
-
-                return !x.Equals(y);
-            }
+                => !Equals(x, y);
 
             private static bool AreDifferent(IReadOnlyList<Argument> x, IReadOnlyList<Argument> y)
             {
diff --git a/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs b/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs
@@ -2,7 +2,6 @@
 using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Extensions;
-using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Running;
@@ -19,28 +18,31 @@ namespace BenchmarkDotNet.Toolchains
 {
     internal static class ToolchainExtensions
     {
-        internal static IToolchain GetToolchain(this BenchmarkCase benchmarkCase) => GetToolchain(benchmarkCase.Job, benchmarkCase.Descriptor);
-
-        internal static IToolchain GetToolchain(this Job job) => GetToolchain(job, null);
+        internal static IToolchain GetToolchain(this BenchmarkCase benchmarkCase)
+            => benchmarkCase.Job.Infrastructure.TryGetToolchain(out var toolchain)
+                ? toolchain
+                : GetToolchain(
+                    benchmarkCase.GetRuntime(),
+                    benchmarkCase.Descriptor,
+                    benchmarkCase.Job.HasDynamicBuildCharacteristic()
+                );
 
-        private static IToolchain GetToolchain(Job job, Descriptor descriptor)
+        internal static IToolchain GetToolchain(this Job job)
             => job.Infrastructure.TryGetToolchain(out var toolchain)
                 ? toolchain
                 : GetToolchain(
                     job.ResolveValue(EnvironmentMode.RuntimeCharacteristic, EnvironmentResolver.Instance),
-                    descriptor,
-                    job.HasDynamicBuildCharacteristic());
+                    null,
+                    job.HasDynamicBuildCharacteristic()
+                );
 
         internal static IToolchain GetToolchain(this Runtime runtime, Descriptor? descriptor = null, bool preferMsBuildToolchains = false)
         {
             switch (runtime)
             {
                 case ClrRuntime clrRuntime:
-                    if (!preferMsBuildToolchains && RuntimeInformation.IsFullFramework
-                        && RuntimeInformation.GetCurrentRuntime().MsBuildMoniker == runtime.MsBuildMoniker)
-                    {
+                    if (!preferMsBuildToolchains && RuntimeInformation.IsFullFramework)
                         return RoslynToolchain.Instance;
-                    }
 
                     return clrRuntime.RuntimeMoniker != RuntimeMoniker.NotRecognized
                         ? GetToolchain(clrRuntime.RuntimeMoniker)

Original file line number	Diff line number	Diff line change
`@@ -182,6 +182,11 @@ string GetDetailedVersion()`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`
	`185`	`+ internal static Runtime GetTargetOrCurrentRuntime(Assembly? assembly)`
	`186`	`+ => !IsMono && !IsWasm && IsFullFramework // Match order of checks in GetCurrentRuntime().`
	`187`	`+ ? ClrRuntime.GetTargetOrCurrentVersion(assembly)`
	`188`	`+ : GetCurrentRuntime();`
	`189`	`+`
`185`	`190`	`internal static Runtime GetCurrentRuntime()`
`186`	`191`	`{`
`187`	`192`	`//do not change the order of conditions because it may cause incorrect determination of runtime`