Add triggers resolution benchmarks

Author: fabien.menager

benchmarks/EntityFrameworkCore.Triggered.Benchmarks/AssemblyTriggersBenchmarks.cs

@@ -0,0 +1,193 @@
+using System;
+using System.Reflection;
+using BenchmarkDotNet.Attributes;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EntityFrameworkCore.Triggered.Benchmarks
+{
+    /// <summary>
+    /// Measures the setup cost (assembly scan + trigger registration) without building the
+    /// ServiceProvider, isolating the overhead of AddAssemblyTriggers vs explicit AddTrigger&lt;T&gt;.
+    ///
+    /// Note: TriggerTypeHelper caches results per type after the first iteration.
+    /// BenchmarkDotNet measures steady-state (warm cache).
+    /// </summary>
+    [MemoryDiagnoser]
+    public class AssemblyTriggersSetupBenchmarks
+    {
+        private static readonly Assembly BenchmarkAssembly = typeof(AssemblyTriggersSetupBenchmarks).Assembly;
+
+        /// <summary>
+        /// Baseline: 2 triggers registered explicitly via AddTrigger&lt;T&gt;() inside UseTriggers().
+        /// </summary>
+        [Benchmark(Baseline = true)]
+        public IServiceCollection Explicit_2Triggers_ViaOptions()
+        {
+            return new ServiceCollection()
+                .AddDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("Setup_Explicit_Options").UseTriggers(o =>
+                    {
+                        o.AddTrigger<Triggers.SetStudentRegistrationDateTrigger>();
+                        o.AddTrigger<Triggers.SignStudentUpForMandatoryCourses>();
+                    }));
+        }
+
+        /// <summary>
+        /// Assembly scan via TriggersContextOptionsBuilder.AddAssemblyTriggers().
+        /// Discovers 2 Student triggers + 5 StudentCourse triggers = 7 types total.
+        /// </summary>
+        [Benchmark]
+        public IServiceCollection AssemblyTriggers_ViaOptions()
+        {
+            return new ServiceCollection()
+                .AddDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("Setup_Assembly_Options").UseTriggers(o =>
+                        o.AddAssemblyTriggers(BenchmarkAssembly)));
+        }
+
+        /// <summary>
+        /// Baseline: 2 triggers registered explicitly via IServiceCollection.AddTrigger&lt;T&gt;().
+        /// </summary>
+        [Benchmark]
+        public IServiceCollection Explicit_2Triggers_ViaServiceCollection()
+        {
+            return new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("Setup_Explicit_SC"))
+                .AddTrigger<Triggers.SetStudentRegistrationDateTrigger>()
+                .AddTrigger<Triggers.SignStudentUpForMandatoryCourses>();
+        }
+
+        /// <summary>
+        /// Assembly scan via IServiceCollection.AddAssemblyTriggers().
+        /// Registers all 7 triggers (2 Student + 5 StudentCourse) directly in the application DI container.
+        /// </summary>
+        [Benchmark]
+        public IServiceCollection AssemblyTriggers_ViaServiceCollection()
+        {
+            return new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("Setup_Assembly_SC"))
+                .AddAssemblyTriggers(BenchmarkAssembly);
+        }
+    }
+
+    /// <summary>
+    /// Measures the per-SaveChanges runtime cost when triggers were registered via
+    /// AddAssemblyTriggers (7 triggers in the assembly = 2 for Student + 5 for StudentCourse)
+    /// vs explicit registration targeting only the 2 Student triggers.
+    ///
+    /// Answers: "Does registering extra non-applicable triggers (discovered by assembly scan)
+    /// slow down the hot path?"
+    ///
+    /// A new DbContext is created on every iteration to include instantiation cost.
+    /// </summary>
+    [MemoryDiagnoser]
+    public class AssemblyTriggersRuntimeBenchmarks
+    {
+        private static readonly Assembly BenchmarkAssembly = typeof(AssemblyTriggersRuntimeBenchmarks).Assembly;
+
+        private IServiceProvider _explicit2OptionsProvider;
+        private IServiceProvider _assemblyScan7OptionsProvider;
+        private IServiceProvider _explicit2ServiceCollectionProvider;
+        private IServiceProvider _assemblyScan7ServiceCollectionProvider;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            _explicit2OptionsProvider = new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("RT_Explicit_Options").UseTriggers(o =>
+                    {
+                        o.AddTrigger<Triggers.SetStudentRegistrationDateTrigger>();
+                        o.AddTrigger<Triggers.SignStudentUpForMandatoryCourses>();
+                    }))
+                .BuildServiceProvider();
+
+            _assemblyScan7OptionsProvider = new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("RT_Assembly_Options").UseTriggers(o =>
+                        o.AddAssemblyTriggers(BenchmarkAssembly)))
+                .BuildServiceProvider();
+
+            _explicit2ServiceCollectionProvider = new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("RT_Explicit_SC"))
+                .AddTrigger<Triggers.SetStudentRegistrationDateTrigger>()
+                .AddTrigger<Triggers.SignStudentUpForMandatoryCourses>()
+                .BuildServiceProvider();
+
+            _assemblyScan7ServiceCollectionProvider = new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("RT_Assembly_SC"))
+                .AddAssemblyTriggers(BenchmarkAssembly)
+                .BuildServiceProvider();
+
+            SeedCourse(_explicit2OptionsProvider);
+            SeedCourse(_assemblyScan7OptionsProvider);
+            SeedCourse(_explicit2ServiceCollectionProvider);
+            SeedCourse(_assemblyScan7ServiceCollectionProvider);
+        }
+
+        private static void SeedCourse(IServiceProvider sp)
+        {
+            using var scope = sp.CreateScope();
+            using var ctx = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            ctx.Database.EnsureCreated();
+            ctx.Courses.Add(new Course { Id = Guid.NewGuid(), DisplayName = "Mandatory", IsMandatory = true });
+            ctx.SaveChanges();
+        }
+
+        /// <summary>
+        /// Baseline: 2 Student triggers registered explicitly via UseTriggers options.
+        /// </summary>
+        [Benchmark(Baseline = true)]
+        public void Explicit_2Triggers_ViaOptions()
+        {
+            using var scope = _explicit2OptionsProvider.CreateScope();
+            using var ctx = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            ctx.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            ctx.SaveChanges();
+        }
+
+        /// <summary>
+        /// 7 triggers registered via assembly scan (2 Student + 5 StudentCourse) through UseTriggers options.
+        /// Only the 2 Student triggers are invoked during this SaveChanges.
+        /// </summary>
+        [Benchmark]
+        public void AssemblyTriggers_7Registered_2Active_ViaOptions()
+        {
+            using var scope = _assemblyScan7OptionsProvider.CreateScope();
+            using var ctx = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            ctx.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            ctx.SaveChanges();
+        }
+
+        /// <summary>
+        /// Baseline (application DI path): 2 Student triggers registered explicitly via IServiceCollection.
+        /// </summary>
+        [Benchmark]
+        public void Explicit_2Triggers_ViaServiceCollection()
+        {
+            using var scope = _explicit2ServiceCollectionProvider.CreateScope();
+            using var ctx = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            ctx.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            ctx.SaveChanges();
+        }
+
+        /// <summary>
+        /// 7 triggers registered via assembly scan (2 Student + 5 StudentCourse) through IServiceCollection.
+        /// Only the 2 Student triggers are invoked during this SaveChanges.
+        /// </summary>
+        [Benchmark]
+        public void AssemblyTriggers_7Registered_2Active_ViaServiceCollection()
+        {
+            using var scope = _assemblyScan7ServiceCollectionProvider.CreateScope();
+            using var ctx = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            ctx.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            ctx.SaveChanges();
+        }
+    }
+}
+

benchmarks/EntityFrameworkCore.Triggered.Benchmarks/EntityFrameworkCore.Triggered.Benchmarks.csproj

@@ -17,6 +17,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\EntityFrameworkCore.Triggered\EntityFrameworkCore.Triggered.csproj" />
+    <ProjectReference Include="..\..\src\EntityFrameworkCore.Triggered.Extensions\EntityFrameworkCore.Triggered.Extensions.csproj" />
   </ItemGroup>
 
 </Project>

benchmarks/EntityFrameworkCore.Triggered.Benchmarks/TriggerResolutionBenchmarks.cs

@@ -0,0 +1,115 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EntityFrameworkCore.Triggered.Benchmarks
+{
+    /// <summary>
+    /// Measures trigger resolution cost in isolation by creating a new DbContext on every iteration.
+    /// This exposes the per-instantiation overhead of the triggered infrastructure compared to a
+    /// plain DbContext, and how that overhead scales with the number of registered triggers.
+    /// </summary>
+    [MemoryDiagnoser]
+    public class TriggerResolutionBenchmarks
+    {
+        private IServiceProvider _plainServiceProvider;
+        private IServiceProvider _triggered0ServiceProvider;  // UseTriggers() with no triggers registered
+        private IServiceProvider _triggered1ServiceProvider;  // 1 lightweight trigger (no DB query)
+        private IServiceProvider _triggered2ServiceProvider;  // 2 triggers, one of which queries the DB
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            _plainServiceProvider = new ServiceCollection()
+                .AddDbContext<ApplicationContext>(options =>
+                    options.UseInMemoryDatabase("TriggerResolution_Plain"))
+                .BuildServiceProvider();
+
+            _triggered0ServiceProvider = new ServiceCollection()
+                .AddDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("TriggerResolution_T0").UseTriggers())
+                .BuildServiceProvider();
+
+            _triggered1ServiceProvider = new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("TriggerResolution_T1").UseTriggers(triggerOptions =>
+                        triggerOptions.AddTrigger<Triggers.SetStudentRegistrationDateTrigger>()))
+                .BuildServiceProvider();
+
+            _triggered2ServiceProvider = new ServiceCollection()
+                .AddTriggeredDbContext<TriggeredApplicationContext>(options =>
+                    options.UseInMemoryDatabase("TriggerResolution_T2").UseTriggers(triggerOptions =>
+                    {
+                        triggerOptions.AddTrigger<Triggers.SetStudentRegistrationDateTrigger>();
+                        triggerOptions.AddTrigger<Triggers.SignStudentUpForMandatoryCourses>();
+                    }))
+                .BuildServiceProvider();
+
+            // Seed a mandatory course so SignStudentUpForMandatoryCourses has data to work with.
+            SeedCourse(_triggered2ServiceProvider);
+        }
+
+        private static void SeedCourse(IServiceProvider serviceProvider)
+        {
+            using var scope = serviceProvider.CreateScope();
+            using var context = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            context.Database.EnsureCreated();
+            context.Courses.Add(new Course { Id = Guid.NewGuid(), DisplayName = "Mandatory Course", IsMandatory = true });
+            context.SaveChanges();
+        }
+
+        /// <summary>
+        /// Baseline: standard DbContext with no triggered infrastructure.
+        /// A new scope and DbContext are created on each iteration.
+        /// </summary>
+        [Benchmark(Baseline = true)]
+        public void PlainDbContext()
+        {
+            using var scope = _plainServiceProvider.CreateScope();
+            using var context = scope.ServiceProvider.GetRequiredService<ApplicationContext>();
+            context.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            context.SaveChanges();
+        }
+
+        /// <summary>
+        /// Triggered infrastructure enabled (UseTriggers), but no triggers registered.
+        /// Measures the raw overhead of the trigger resolution engine with an empty registry.
+        /// </summary>
+        [Benchmark]
+        public void TriggeredDbContext_NoTriggers()
+        {
+            using var scope = _triggered0ServiceProvider.CreateScope();
+            using var context = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            context.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            context.SaveChanges();
+        }
+
+        /// <summary>
+        /// 1 trigger registered: SetStudentRegistrationDateTrigger (synchronous, no DB query).
+        /// Measures resolution + execution cost for a lightweight trigger.
+        /// </summary>
+        [Benchmark]
+        public void TriggeredDbContext_OneTrigger()
+        {
+            using var scope = _triggered1ServiceProvider.CreateScope();
+            using var context = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            context.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            context.SaveChanges();
+        }
+
+        /// <summary>
+        /// 2 triggers registered: SetStudentRegistrationDateTrigger + SignStudentUpForMandatoryCourses
+        /// (the second performs a DB query and adds new entities).
+        /// Measures resolution + execution cost for triggers with side effects.
+        /// </summary>
+        [Benchmark]
+        public void TriggeredDbContext_TwoTriggers()
+        {
+            using var scope = _triggered2ServiceProvider.CreateScope();
+            using var context = scope.ServiceProvider.GetRequiredService<TriggeredApplicationContext>();
+            context.Students.Add(new Student { Id = Guid.NewGuid(), DisplayName = "Test" });
+            context.SaveChanges();
+        }
+    }
+}

benchmarks/EntityFrameworkCore.Triggered.Benchmarks/Triggers/DummyStudentCourseTriggers.cs

@@ -0,0 +1,33 @@
+namespace EntityFrameworkCore.Triggered.Benchmarks.Triggers
+{
+    // These "noise" triggers implement IBeforeSaveTrigger<StudentCourse> (not IBeforeSaveTrigger<Student>).
+    // They are used to simulate an assembly containing several triggers where only a subset applies
+    // to the entity being saved — a typical real-world scenario.
+    // AddAssemblyTriggers will discover and register them, but they will never be resolved
+    // during a SaveChanges that only tracks Student entities.
+
+    public class DummyStudentCourseTrigger1 : IBeforeSaveTrigger<StudentCourse>
+    {
+        public void BeforeSave(ITriggerContext<StudentCourse> context) { }
+    }
+
+    public class DummyStudentCourseTrigger2 : IBeforeSaveTrigger<StudentCourse>
+    {
+        public void BeforeSave(ITriggerContext<StudentCourse> context) { }
+    }
+
+    public class DummyStudentCourseTrigger3 : IBeforeSaveTrigger<StudentCourse>
+    {
+        public void BeforeSave(ITriggerContext<StudentCourse> context) { }
+    }
+
+    public class DummyStudentCourseTrigger4 : IBeforeSaveTrigger<StudentCourse>
+    {
+        public void BeforeSave(ITriggerContext<StudentCourse> context) { }
+    }
+
+    public class DummyStudentCourseTrigger5 : IBeforeSaveTrigger<StudentCourse>
+    {
+        public void BeforeSave(ITriggerContext<StudentCourse> context) { }
+    }
+}