.NET 6 v .NET 7 Reflection Benchmarks

ReflectionBenchmarks.cs

using System.Linq;
using System.Reflection;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Columns;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Reports;

namespace BenchmarkDotNet.Samples
{
    [Config(typeof(Config))]
    [SimpleJob(RuntimeMoniker.Net60, baseline:true)]
    [SimpleJob(RuntimeMoniker.Net70)]
    public class ReflectionBenchmarks
    {
        [Benchmark]
        public void MethodInvoke()
        {
            var instance = new Target();
            var method =
                typeof(Target)
                    .GetMethod("One",
                        BindingFlags.Instance |
                        BindingFlags.Public
                    );

            method.Invoke(instance, parameters: null);
        }

        [Benchmark]
        public void PrivateMethodInvoke()
        {
            var instance = new Target();
            var method =
                typeof(Target)
                    .GetMethod("GetSecret",
                        BindingFlags.Instance |
                        BindingFlags.NonPublic
                    );

            var result =
                method.Invoke(instance, parameters: null);
        }

        [Benchmark]
        public void PrivateField()
        {
            var instance = new Target();
            var field =
                typeof(Target)
                    .GetField("secret",
                        BindingFlags.Instance |
                        BindingFlags.NonPublic
                    );

            var value =
                (string)field.GetValue(instance);
        }

        [Benchmark]
        public void GenericMethod()
        {
            var instance = new Target();
            var method =
                typeof(Target)
                    .GetMethod("Generic",
                        BindingFlags.Instance |
                        BindingFlags.Public
                    );

            var generic =
                method.MakeGenericMethod(typeof(string));

            var result =
                generic.Invoke(instance, new[] { "David" });
        }

        [Benchmark]
        public void AllPublicMethods()
        {
            var instance = new Target();
            var members =
                typeof(Target)
                    .GetMembers(
                        BindingFlags.Instance |
                        BindingFlags.Public |
                        BindingFlags.DeclaredOnly
                    )
                    .Where(x =>
                        !x.Name.StartsWith("get_") &&
                        !x.Name.StartsWith("set_")
                    )
                    .ToList();
        }

        public class Target
        {
            public void One(){
                var one = 1;
            }
            private string GetSecret() => "42";

            private string secret = "42";

            public string Generic<T>(T input) => $"Hello {input}!";

            public void Zero() { }
            public string OneA { get; set; }
            public string TwoB { get; set; }
        }

        private class Config : ManualConfig
        {
            public Config()
            {
                SummaryStyle =
                    SummaryStyle.Default.WithRatioStyle(RatioStyle.Percentage);
            }
        }
    }
}