Build again with actual tfm if the first build failed.

Author: timcassell

src/BenchmarkDotNet/Environments/Runtimes/CoreRuntime.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Versioning;
+using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Portability;
 
@@ -47,10 +48,11 @@ public static CoreRuntime CreateForNewVersion(string msBuildMoniker, string disp
         }
 
         internal static CoreRuntime GetTargetOrCurrentVersion(Assembly? assembly)
-            // Try to determine the Framework version that the assembly was compiled for.
-            => GetTargetFrameworkVersion(assembly)
+            // Try to determine the version that the assembly was compiled for.
+            => FrameworkVersionHelper.GetTargetCoreVersion(assembly) is { } version
+                ? FromVersion(version)
                 // Fallback to the current running version.
-                ?? GetCurrentVersion();
+                : GetCurrentVersion();
 
         internal static CoreRuntime GetCurrentVersion()
         {
@@ -249,24 +251,5 @@ private static CoreRuntime GetPlatformSpecific(CoreRuntime fallback)
 
             return new CoreRuntime(fallback.RuntimeMoniker, $"{fallback.MsBuildMoniker}-{platformName}", fallback.Name);
         }
-
-        private static CoreRuntime? GetTargetFrameworkVersion(Assembly? assembly)
-        {
-            //.NETCoreApp,Version=vX.Y
-            const string FrameworkPrefix = ".NETCoreApp,Version=v";
-            // Look for a TargetFrameworkAttribute with a supported Framework version.
-            string? framework = assembly?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;
-            if (framework?.StartsWith(FrameworkPrefix) == true
-                && Version.TryParse(framework[FrameworkPrefix.Length..], out var version)
-                // We don't support netcoreapp1.X
-                && version.Major >= 2)
-            {
-                return FromVersion(version);
-            }
-
-            // Null assembly, or TargetFrameworkAttribute not found, or the assembly targeted a version older than we support,
-            // or the assembly targeted a non-core tfm (like netstandard2.0).
-            return null;
-        }
     }
 }

src/BenchmarkDotNet/Helpers/FrameworkVersionHelper.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -38,6 +39,26 @@ private static readonly (int minReleaseNumber, string version)[] FrameworkVersio
                 _ => null,
             };
 
+        internal static Version? GetTargetCoreVersion(Assembly? assembly)
+        {
+            //.NETCoreApp,Version=vX.Y
+            const string FrameworkPrefix = ".NETCoreApp,Version=v";
+
+            // Look for a TargetFrameworkAttribute with a supported Framework version.
+            string? framework = assembly?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;
+            if (framework?.StartsWith(FrameworkPrefix) == true
+                && Version.TryParse(framework[FrameworkPrefix.Length..], out var version)
+                // We don't support netcoreapp1.X
+                && version.Major >= 2)
+            {
+                return version;
+            }
+
+            // Null assembly, or TargetFrameworkAttribute not found, or the assembly targeted a version older than we support,
+            // or the assembly targeted a non-core tfm (like netstandard2.0).
+            return null;
+        }
+
         internal static string GetFrameworkDescription()
         {
             var fullName = System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription; // sth like .NET Framework 4.7.3324.0
@@ -102,5 +123,42 @@ private static bool IsDeveloperPackInstalled(string version) => Directory.Exists
             Environment.Is64BitOperatingSystem
                 ? Environment.SpecialFolder.ProgramFilesX86
                 : Environment.SpecialFolder.ProgramFiles);
+
+        internal static string? GetTfm(Assembly assembly)
+        {
+            // We don't support exotic frameworks like Silverlight, WindowsPhone, Xamarin.Mac, etc.
+            const string CorePrefix = ".NETCoreApp,Version=v";
+            const string FrameworkPrefix = ".NETFramework,Version=v";
+            const string StandardPrefix = ".NETStandard,Version=v";
+
+            // Look for a TargetFrameworkAttribute with a supported Framework version.
+            string? framework = assembly.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;
+            if (TryParseVersion(CorePrefix, out var version))
+            {
+                return version.Major < 5
+                    ? $"netcoreapp{version.Major}.{version.Minor}"
+                    : $"net{version.Major}.{version.Minor}";
+            }
+            if (TryParseVersion(FrameworkPrefix, out version))
+            {
+                return version.Build > 0
+                    ? $"net{version.Major}{version.Minor}{version.Build}"
+                    : $"net{version.Major}{version.Minor}";
+            }
+            if (!TryParseVersion(StandardPrefix, out version))
+            {
+                return $"netstandard{version.Major}.{version.Minor}";
+            }
+
+            // TargetFrameworkAttribute not found, or the assembly targeted a framework we don't support,
+            return null;
+
+            bool TryParseVersion(string prefix, [NotNullWhen(true)] out Version? version)
+            {
+                version = null;
+                return framework?.StartsWith(prefix) == true
+                    && Version.TryParse(framework[CorePrefix.Length..], out version);
+            }
+        }
     }
 }

src/BenchmarkDotNet/Toolchains/CsProj/CsProjGenerator.cs

@@ -112,18 +112,16 @@ protected override void GenerateProject(BuildPartition buildPartition, Artifacts
         protected void GatherReferences(string projectFilePath, BuildPartition buildPartition, ArtifactsPaths artifactsPaths, ILogger logger)
         {
             // Build the original project then reference all of the built dlls.
-            var buildResult = new DotNetCliCommand(
-                CliPath,
-                projectFilePath,
-                TargetFrameworkMoniker,
-                null,
-                GenerateResult.Success(artifactsPaths, []),
-                logger,
-                buildPartition,
-                [],
-                buildPartition.Timeout
-            )
-            .RestoreThenBuild();
+            BuildResult buildResult = BuildProject(TargetFrameworkMoniker);
+
+            // The build could fail because the project doesn't have a tfm that matches the runtime, e.g. netstandard2.0 vs net10.0,
+            // So we try to get the actual tfm of the assembly and build again.
+            if (!buildResult.IsBuildSuccess
+                && FrameworkVersionHelper.GetTfm(buildPartition.RepresentativeBenchmarkCase.Descriptor.Type.Assembly) is { } actualTfm
+                && actualTfm != TargetFrameworkMoniker)
+            {
+                buildResult = BuildProject(actualTfm);
+            }
 
             if (!buildResult.IsBuildSuccess)
             {
@@ -153,6 +151,20 @@ protected void GatherReferences(string projectFilePath, BuildPartition buildPart
             }
 
             xmlDoc.Save(artifactsPaths.ProjectFilePath);
+
+            BuildResult BuildProject(string tfm)
+                => new DotNetCliCommand(
+                    CliPath,
+                    projectFilePath,
+                    tfm,
+                    null,
+                    GenerateResult.Success(artifactsPaths, []),
+                    logger,
+                    buildPartition,
+                    [],
+                    buildPartition.Timeout
+                )
+                .RestoreThenBuild();
         }
 
         /// <summary>