Adds Microsoft.Extensions.* performance tests with history

src/benchmarks/micro/MicroBenchmarks.csproj

@@ -6,7 +6,7 @@
     <!-- Supported target frameworks -->
     <TargetFrameworks Condition="'$(TargetFrameworks)' == '' AND '$(OS)' == 'Windows_NT'">net461;netcoreapp2.1;netcoreapp3.1;netcoreapp5.0</TargetFrameworks>
     <TargetFrameworks Condition="'$(TargetFrameworks)' == ''">netcoreapp2.1;netcoreapp3.1;netcoreapp5.0</TargetFrameworks>
-
+    <NoWarn>$(NoWarn);CS8002</NoWarn>
     <OutputType>Exe</OutputType>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <DebugType>portable</DebugType>
@@ -21,6 +21,11 @@
     <PackageReference Include="MessagePack" Version="1.9.11" />
     <PackageReference Include="MessagePackAnalyzer" Version="1.7.3.7" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="5.0.0-preview.4.20251.6" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.0-preview.4.20251.6" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="5.0.0-preview.4.20251.6" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0-preview.4.20251.6" />
+    <PackageReference Include="Microsoft.Extensions.Logging.EventSource" Version="5.0.0-preview.4.20251.6" />
+    <PackageReference Include="Microsoft.Extensions.Primitives" Version="5.0.0-preview.4.20251.6" />
     <PackageReference Include="protobuf-net" Version="2.4.0" />
     <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
     <PackageReference Include="System.IO.Pipelines" Version="4.5.3" />

src/benchmarks/micro/libraries/Microsoft.Extensions.DependencyInjection/ActivatorUtilitiesBenchmark.cs

@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace Microsoft.Extensions.DependencyInjection
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class ActivatorUtilitiesBenchmark
+    {
+        private ServiceProvider _serviceProvider;
+        private ObjectFactory _factory;
+        private object[] _factoryArguments;
+
+        [GlobalSetup]
+        public void SetUp()
+        {
+            var collection = new ServiceCollection();
+            collection.AddTransient<TypeToBeActivated>();
+            collection.AddSingleton<DependencyA>();
+            collection.AddSingleton<DependencyB>();
+            collection.AddSingleton<DependencyC>();
+            collection.AddTransient<TypeToBeActivated>();
+
+            _serviceProvider = collection.BuildServiceProvider();
+            _factory = ActivatorUtilities.CreateFactory(typeof(TypeToBeActivated), new Type[] { typeof(DependencyB), typeof(DependencyC) });
+            _factoryArguments = new object[] { new DependencyB(), new DependencyC() };
+        }
+
+        [Benchmark]
+        public TypeToBeActivated ServiceProvider() => _serviceProvider.GetService<TypeToBeActivated>();
+
+        [Benchmark]
+        public TypeToBeActivated Factory() => (TypeToBeActivated)_factory(_serviceProvider, _factoryArguments);
+
+        [Benchmark]
+        public TypeToBeActivated CreateInstance() => ActivatorUtilities.CreateInstance<TypeToBeActivated>(_serviceProvider, _factoryArguments);
+
+        public class TypeToBeActivated
+        {
+            public TypeToBeActivated(int i)
+            {
+                throw new NotImplementedException();
+            }
+
+            public TypeToBeActivated(string s)
+            {
+                throw new NotImplementedException();
+            }
+
+            public TypeToBeActivated(object o)
+            {
+                throw new NotImplementedException();
+            }
+
+            public TypeToBeActivated(DependencyA a, DependencyB b, DependencyC c)
+            {
+            }
+        }
+
+        public class DependencyA {}
+        public class DependencyB {}
+        public class DependencyC {}
+    }
+}

src/benchmarks/micro/libraries/Microsoft.Extensions.DependencyInjection/GetServiceBenchmark.cs

@@ -0,0 +1,121 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace Microsoft.Extensions.DependencyInjection
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class GetService :  ServiceProviderEngineBenchmark
+    {
+        private IServiceProvider _transientSp;
+        private IServiceScope _scopedSp;
+        private IServiceProvider _singletonSp;
+        private IServiceProvider _serviceScopeFactoryProvider;
+        private IServiceProvider _serviceScope;
+        private IServiceProvider _emptyEnumerable;
+
+        [Benchmark(Baseline = true)]
+        public A NoDI() => new A(new B(new C()));
+
+        [GlobalSetup(Target = nameof(Transient))]
+        public void SetupTransient()
+        {
+            var services = new ServiceCollection();
+            services.AddTransient<A>();
+            services.AddTransient<B>();
+            services.AddTransient<C>();
+            _transientSp = services.BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            });
+        }
+
+        [Benchmark]
+        public A Transient() => _transientSp.GetService<A>();
+
+        [GlobalSetup(Target = nameof(Scoped))]
+        public void SetupScoped()
+        {
+            var services = new ServiceCollection();
+            services.AddScoped<A>();
+            services.AddScoped<B>();
+            services.AddScoped<C>();
+            _scopedSp = services.BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            }).CreateScope();
+        }
+
+        [Benchmark]
+        public A Scoped() => _scopedSp.ServiceProvider.GetService<A>();
+
+        [GlobalSetup(Target = nameof(Singleton))]
+        public void SetupScopedSingleton()
+        {
+            var services = new ServiceCollection();
+            services.AddSingleton<A>();
+            services.AddSingleton<B>();
+            services.AddSingleton<C>();
+            _singletonSp = services.BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            });
+        }
+
+        [Benchmark]
+        public A Singleton() => _singletonSp.GetService<A>();
+
+        [GlobalSetup(Target = nameof(ServiceScope))]
+        public void ServiceScopeSetup()
+        {
+            _serviceScope = new ServiceCollection().BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            });
+        }
+
+        [Benchmark]
+        public IServiceScope ServiceScope() => _serviceScope.CreateScope();
+
+        [GlobalSetup(Target = nameof(ServiceScopeProvider))]
+        public void ServiceScopeProviderSetup()
+        {
+            _serviceScopeFactoryProvider = new ServiceCollection().BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            });
+        }
+
+        [Benchmark]
+        public IServiceScopeFactory ServiceScopeProvider() => _serviceScopeFactoryProvider.GetService<IServiceScopeFactory>();
+
+        [GlobalSetup(Target = nameof(EmptyEnumerable))]
+        public void EmptyEnumerableSetup()
+        {
+            _emptyEnumerable = new ServiceCollection().BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            });
+        }
+
+        [Benchmark]
+        public object EmptyEnumerable() =>_emptyEnumerable.GetService<IEnumerable<A>>();
+    }
+}

src/benchmarks/micro/libraries/Microsoft.Extensions.DependencyInjection/IEnumerableGetServiceBenchmark.cs

@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace Microsoft.Extensions.DependencyInjection
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class GetServiceIEnumerable : ServiceProviderEngineBenchmark
+    {
+        private IServiceProvider _serviceProvider;
+
+        [GlobalSetup(Target = nameof(Transient))]
+        public void SetupTransient() => Setup(ServiceLifetime.Transient);
+
+        [GlobalSetup(Target = nameof(Scoped))]
+        public void SetupScoped() => Setup(ServiceLifetime.Scoped);
+
+        [GlobalSetup(Target = nameof(Singleton))]
+        public void SetupSingleton() => Setup(ServiceLifetime.Singleton);
+
+        private void Setup(ServiceLifetime lifetime)
+        {
+            IServiceCollection services = new ServiceCollection();
+            for (int i = 0; i < 10; i++)
+            {
+                services.Add(ServiceDescriptor.Describe(typeof(A), typeof(A), lifetime));
+            }
+
+            services.Add(ServiceDescriptor.Describe(typeof(B), typeof(B), lifetime));
+            services.Add(ServiceDescriptor.Describe(typeof(C), typeof(C), lifetime));
+
+            _serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions()
+            {
+#if INTERNAL_DI
+                Mode = ServiceProviderMode
+#endif
+            }).CreateScope().ServiceProvider;
+        }
+
+        [Benchmark]
+        public object Transient() => _serviceProvider.GetService<IEnumerable<A>>();
+
+        [Benchmark]
+        public object Scoped() => _serviceProvider.GetService<IEnumerable<A>>();
+
+        [Benchmark]
+        public object Singleton() => _serviceProvider.GetService<IEnumerable<A>>();
+    }
+}

src/benchmarks/micro/libraries/Microsoft.Extensions.DependencyInjection/ScopeValidationBenchmark.cs

@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace Microsoft.Extensions.DependencyInjection
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class ScopeValidation
+    {
+        private IServiceProvider _transientSp;
+        private IServiceProvider _transientSpScopeValidation;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            var services = new ServiceCollection();
+            services.AddTransient<A>();
+            services.AddTransient<B>();
+            services.AddTransient<C>();
+            _transientSp = services.BuildServiceProvider();
+
+            services = new ServiceCollection();
+            services.AddTransient<A>();
+            services.AddTransient<B>();
+            services.AddTransient<C>();
+            _transientSpScopeValidation = services.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true });
+        }
+
+        [Benchmark(Baseline = true)]
+        public A Transient() => _transientSp.GetService<A>();
+
+        [Benchmark]
+        public A TransientWithScopeValidation() => _transientSpScopeValidation.GetService<A>();
+
+        public class A
+        {
+            public A(B b) { }
+        }
+
+        public class B
+        {
+            public B(C c) { }
+        }
+        public class C { }
+    }
+}

src/benchmarks/micro/libraries/Microsoft.Extensions.DependencyInjection/ServiceProviderEngineBenchmark.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace Microsoft.Extensions.DependencyInjection
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class ServiceProviderEngineBenchmark
+    {
+#if INTERNAL_DI
+        internal ServiceProviderMode ServiceProviderMode { get; private set; }
+
+        [Params("Expressions", "Dynamic", "Runtime", "ILEmit")]
+        public string Mode {
+            set {
+                ServiceProviderMode = (ServiceProviderMode)Enum.Parse(typeof(ServiceProviderMode), value);
+            }
+        }
+#endif
+
+        public class A
+        {
+            public A(B b) { }
+        }
+
+        public class B
+        {
+            public B(C c) { }
+        }
+
+        public class C { }
+    }
+}