What causes "Registered event handler for event type {eventType.Name} is null!" in aspnetboilerplate/aspnetboilerplate?

Inspect the handler registration for that event type and fix the factory/IoC registration so GetHandler returns a valid instance.

aspnetboilerplate/aspnetboilerplate · error · ArgumentNullException

Registered event handler for event type

Error message

Registered event handler for event type {eventType.Name} is null!

What it means

EventBus.TriggerHandlingException resolves a handler instance from its factory before invoking HandleEvent via reflection; when the factory returns null it throws ArgumentNullException with this message. It means a registered handler factory produced no usable handler instance for the event type — an invalid registration rather than a handler bug.

Solutions

Inspect the handler registration for that event type and fix the factory/IoC registration so GetHandler returns a valid instance.
Ensure the handler class's constructor dependencies are all registered in the DI container.
If using a custom factory, make GetHandler throw a descriptive exception instead of returning null.
Test handler resolution in isolation (resolve the handler type from IocManager) to find the null source.

Example fix

// before
Configuration.EventBus.Register<MyEvent>(() => null); // or custom factory returning null
// after
Configuration.EventBus.Register<MyEvent>(() => new MyEventHandler(new Dep()));

Defensive patterns

Strategy: validation

Validate before calling

var handler = iocManager.IsRegistered<MyEventHandler>() ? iocManager.Resolve<MyEventHandler>() : null;
if (handler == null)
    throw new InvalidOperationException("MyEventHandler cannot be resolved — fix registration before publishing");

Try / catch

try
{
    _eventBus.Trigger(myEvent);
}
catch (ArgumentNullException ex) when (ex.Message.Contains("event handler") && ex.Message.Contains("is null"))
{
    Logger.Error("Broken event handler registration", ex);
}

Prevention

Never let custom handler factories return null; throw with context instead
Resolve-ability-test all handlers at startup
Keep registrations and handler implementations in sync (delete both together)
Ensure handler constructor dependencies are registered in DI

When it happens

Trigger: Publishing an event whose registered IEventHandlerFactory.GetHandler() returns null — e.g. a handler registered as transient with a broken IoC registration, an unresolvable dependency, or a custom factory that can't create the handler.

Common situations: Custom IEventHandlerFactory implementations returning null on failure; handler registered with a type whose constructor dependencies fail silently; removal of a service the handler depends on during refactoring; faulty UntypedHandlerFactory usage.

Related errors

AI-assisted analysis of aspnetboilerplate/aspnetboilerplate@2323c13a15 (2026-09-08). Data as JSON: /api/errors/55ff2598ff2e8e6d. Report an issue: GitHub.

Appendix: source

Thrown at src/Abp/Events/Bus/EventBus.cs:370

            if (exceptions.Any())
            {
                if (exceptions.Count == 1)
                {
                    exceptions[0].ReThrow();
                }

                throw new AggregateException("More than one error has occurred while triggering the event: " + eventType, exceptions);
            }
        }

        private void TriggerHandlingException(IEventHandlerFactory handlerFactory, Type eventType, IEventData eventData, List<Exception> exceptions)
        {
            var eventHandler = handlerFactory.GetHandler();
            try
            {
                if (eventHandler == null)
                {
                    throw new ArgumentNullException($"Registered event handler for event type {eventType.Name} is null!");
                }

                var handlerType = typeof(IEventHandler<>).MakeGenericType(eventType);

                var method = handlerType.GetMethod(
                    "HandleEvent",
                    new[] { eventType }
                );

                method.Invoke(eventHandler, new object[] { eventData });
            }
            catch (TargetInvocationException ex)
            {
                exceptions.Add(ex.InnerException);
            }
            catch (Exception ex)
            {
                exceptions.Add(ex);

View on GitHub (pinned to 2323c13a15)