Materialize trigger collections to eliminate ConcatIterator CPU waste

src/EntityFrameworkCore.Triggered.Extensions/ServiceCollectionExtensions.cs

@@ -1,50 +1,20 @@
 using System;
 using System.Linq;
 using System.Reflection;
-using EntityFrameworkCore.Triggered;
-using EntityFrameworkCore.Triggered.Infrastructure.Internal;
-using EntityFrameworkCore.Triggered.Lifecycles;
+using EntityFrameworkCore.Triggered.Extensions;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace Microsoft.Extensions.DependencyInjection
 {
     public static class ServiceCollectionExtensions
     {
-        static readonly Type[] _wellKnownTriggerTypes = new Type[] {
-                typeof(IBeforeSaveTrigger<>),
-                typeof(IBeforeSaveAsyncTrigger<>),
-                typeof(IAfterSaveTrigger<>),
-                typeof(IAfterSaveAsyncTrigger<>),
-                typeof(IAfterSaveFailedTrigger<>),
-                typeof(IAfterSaveFailedAsyncTrigger<>),
-                typeof(IBeforeSaveStartingTrigger),
-                typeof(IBeforeSaveStartingAsyncTrigger),
-                typeof(IBeforeSaveCompletedTrigger),
-                typeof(IBeforeSaveCompletedAsyncTrigger),
-                typeof(IAfterSaveFailedStartingTrigger),
-                typeof(IAfterSaveFailedStartingAsyncTrigger),
-                typeof(IAfterSaveFailedCompletedTrigger),
-                typeof(IAfterSaveFailedCompletedAsyncTrigger),
-                typeof(IAfterSaveStartingTrigger),
-                typeof(IAfterSaveStartingAsyncTrigger),
-                typeof(IAfterSaveCompletedTrigger),
-                typeof(IAfterSaveCompletedAsyncTrigger)
-            };
-
-        static void RegisterTriggerTypes(Type triggerImplementationType, IServiceCollection services)
+        private static void RegisterTriggerTypes(Type triggerImplementationType, IServiceCollection services)
         {
-            foreach (var customTriggerType in _wellKnownTriggerTypes)
-            {
-                var customTriggers = customTriggerType.IsGenericTypeDefinition
-#pragma warning disable EF1001 // Internal EF Core API usage.
-                    ? TypeHelpers.FindGenericInterfaces(triggerImplementationType, customTriggerType)
-#pragma warning restore EF1001 // Internal EF Core API usage.
-                    : triggerImplementationType.GetInterfaces().Where(x => x == customTriggerType);
+            var triggerInterfaces = TriggerTypeHelper.GetTriggerInterfaces(triggerImplementationType);
 
-                foreach (var customTrigger in customTriggers)
-                {
-                    services.Add(new ServiceDescriptor(customTrigger, sp => sp.GetRequiredService(triggerImplementationType), ServiceLifetime.Transient)); ;
-                }
+            foreach (var triggerInterface in triggerInterfaces)
+            {
+                services.Add(new ServiceDescriptor(triggerInterface, sp => sp.GetRequiredService(triggerImplementationType), ServiceLifetime.Transient));
             }
         }
 
@@ -60,6 +30,11 @@ public static IServiceCollection AddTrigger<TTrigger>(this IServiceCollection se
 
         public static IServiceCollection AddTrigger(this IServiceCollection services, object triggerInstance)
         {
+            if (triggerInstance is null)
+            {
+                throw new ArgumentNullException(nameof(triggerInstance));
+            }
+
             services.TryAddSingleton(triggerInstance);
 
             RegisterTriggerTypes(triggerInstance.GetType(), services);
@@ -83,29 +58,27 @@ public static IServiceCollection AddAssemblyTriggers(this IServiceCollection ser
                 throw new ArgumentNullException(nameof(assemblies));
             }
 
-            var assemblyTypes = assemblies
-                .SelectMany(x => x.GetTypes())
-                .Where(x => x.IsClass)
-                .Where(x => !x.IsAbstract);
+            if (assemblies.Length == 0)
+            {
+                return services;
+            }
+
+            var assemblyTypes = assemblies.SelectMany(TriggerTypeHelper.GetAssemblyConcreteClasses);
 
             foreach (var assemblyType in assemblyTypes)
             {
-                var triggerTypes = assemblyType
-                    .GetInterfaces()
-                    .Where(x => _wellKnownTriggerTypes.Contains(x.IsConstructedGenericType ? x.GetGenericTypeDefinition() : x));
+                var triggerInterfaces = TriggerTypeHelper.GetTriggerInterfaces(assemblyType);
 
-                var registered = false;
-
-                foreach (var triggerType in triggerTypes)
+                if (triggerInterfaces.Length == 0)
                 {
-                    if (!registered)
-                    {
-                        services.TryAdd(new ServiceDescriptor(assemblyType, assemblyType, lifetime));
+                    continue;
+                }
 
-                        registered = true;
-                    }
+                services.TryAdd(new ServiceDescriptor(assemblyType, assemblyType, lifetime));
 
-                    services.Add(new ServiceDescriptor(triggerType, sp => sp.GetRequiredService(assemblyType), ServiceLifetime.Transient));
+                foreach (var triggerInterface in triggerInterfaces)
+                {
+                    services.Add(new ServiceDescriptor(triggerInterface, sp => sp.GetRequiredService(assemblyType), ServiceLifetime.Transient));
                 }
             }
 

src/EntityFrameworkCore.Triggered.Extensions/TriggerTypeHelper.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using EntityFrameworkCore.Triggered.Lifecycles;
+
+namespace EntityFrameworkCore.Triggered.Extensions
+{
+    /// <summary>
+    /// Internal helpers shared between <c>ServiceCollectionExtensions</c> and
+    /// <c>TriggersContextOptionsBuilderExtensions</c> for trigger-type discovery.
+    /// </summary>
+    static internal class TriggerTypeHelper
+    {
+        // Open generic trigger interfaces — add new generic lifecycle interfaces here
+        private readonly static HashSet<Type> _genericTriggerTypes = new HashSet<Type>
+        {
+            typeof(IBeforeSaveTrigger<>),
+            typeof(IBeforeSaveAsyncTrigger<>),
+            typeof(IAfterSaveTrigger<>),
+            typeof(IAfterSaveAsyncTrigger<>),
+            typeof(IAfterSaveFailedTrigger<>),
+            typeof(IAfterSaveFailedAsyncTrigger<>),
+        };
+
+        // Non-generic lifecycle interfaces — add new non-generic lifecycle interfaces here
+        private readonly static HashSet<Type> _nonGenericTriggerTypes = new HashSet<Type>
+        {
+            typeof(IBeforeSaveStartingTrigger),
+            typeof(IBeforeSaveStartingAsyncTrigger),
+            typeof(IBeforeSaveCompletedTrigger),
+            typeof(IBeforeSaveCompletedAsyncTrigger),
+            typeof(IAfterSaveFailedStartingTrigger),
+            typeof(IAfterSaveFailedStartingAsyncTrigger),
+            typeof(IAfterSaveFailedCompletedTrigger),
+            typeof(IAfterSaveFailedCompletedAsyncTrigger),
+            typeof(IAfterSaveStartingTrigger),
+            typeof(IAfterSaveStartingAsyncTrigger),
+            typeof(IAfterSaveCompletedTrigger),
+            typeof(IAfterSaveCompletedAsyncTrigger),
+        };
+
+        // Caches the resolved trigger interfaces per implementation type to avoid repeated reflection
+        private readonly static ConcurrentDictionary<Type, Type[]> _triggerInterfaceCache =
+            new ConcurrentDictionary<Type, Type[]>();
+
+        /// <summary>
+        /// Returns the types defined in <paramref name="assembly"/>, gracefully handling
+        /// <see cref="ReflectionTypeLoadException"/> that occurs when some types cannot be
+        /// loaded due to missing dependencies (e.g. optional assemblies not present at runtime).
+        /// </summary>
+        private static IEnumerable<Type> GetAssemblyTypes(Assembly assembly)
+        {
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException e)
+            {
+                // Return only the types that could be loaded; nulls represent types that failed
+                return e.Types.OfType<Type>();
+            }
+        }
+
+        /// <summary>
+        /// Returns the non-abstract classes defined in <paramref name="assembly"/>, gracefully handling
+        /// <see cref="ReflectionTypeLoadException"/> that occurs when some types cannot be loaded due to missing
+        /// dependencies (e.g. optional assemblies not present at runtime).
+        /// </summary>
+        static internal IEnumerable<Type> GetAssemblyConcreteClasses(Assembly assembly) => 
+            GetAssemblyTypes(assembly).Where(t => t is { IsClass: true, IsAbstract: false });
+
+        /// <summary>
+        /// Returns the subset of <paramref name="triggerImplementationType"/>'s interfaces that
+        /// match a known trigger interface, using a per-type cache.
+        /// </summary>
+        static internal Type[] GetTriggerInterfaces(Type triggerImplementationType)
+            => _triggerInterfaceCache.GetOrAdd(triggerImplementationType, t =>
+            {
+                var interfaces = t.GetInterfaces();
+                var result = new List<Type>(interfaces.Length);
+
+                foreach (var iface in interfaces)
+                {
+                    if (iface.IsConstructedGenericType)
+                    {
+                        if (_genericTriggerTypes.Contains(iface.GetGenericTypeDefinition()))
+                        {
+                            result.Add(iface);
+                        }
+                    }
+                    else if (_nonGenericTriggerTypes.Contains(iface))
+                    {
+                        result.Add(iface);
+                    }
+                }
+
+                return result.ToArray();
+            });
+    }
+}
+
+
+

src/EntityFrameworkCore.Triggered.Extensions/TriggersContextOptionsBuilderExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using EntityFrameworkCore.Triggered.Extensions;
 using EntityFrameworkCore.Triggered.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -24,14 +25,20 @@ public static TriggersContextOptionsBuilder AddAssemblyTriggers(this TriggersCon
                 throw new ArgumentNullException(nameof(assemblies));
             }
 
-            var assemblyTypes = assemblies
-                .SelectMany(x => x.GetTypes())
-                .Where(x => x.IsClass)
-                .Where(x => !x.IsAbstract);
+            if (assemblies.Length == 0)
+            {
+                return builder;
+            }
+
+            var assemblyTypes = assemblies.SelectMany(TriggerTypeHelper.GetAssemblyConcreteClasses);
 
             foreach (var assemblyType in assemblyTypes)
             {
-                builder.AddTrigger(assemblyType, lifetime);
+                // Only register types that actually implement a known trigger interface
+                if (TriggerTypeHelper.GetTriggerInterfaces(assemblyType).Length > 0)
+                {
+                    builder.AddTrigger(assemblyType, lifetime);
+                }
             }
 
             return builder;