Estoy tratando de introducir eventos de dominio en un proyecto. El concepto se describe en la publicación de Udi Dahan -http: //www.udidahan.com/2009/06/14/domain-events-salvation

Aquí está el código de evento de dominio

public interface IDomainEvent { }

public interface IHandleDomainEvents<T> where T : IDomainEvent
{
     void Handle(T args); 
}

public interface IEventDispatcher
{
    void Dispatch<TEvent>(TEvent eventToDispatch) where TEvent : IDomainEvent;
}

public static class DomainEvents
{
    public static IEventDispatcher Dispatcher { get; set; }

    public static void Raise<TEvent>(TEvent eventToRaise) where TEvent : IDomainEvent
    {
        Dispatcher.Dispatch(eventToRaise);
    }
}

La parte más importante es la implementación de IEventDispatcher que desacopla el evento de dominio de lo que sea necesario que suceda cuando se genera el evento. El truco es conectar este acoplamiento a través de un contenedor. Aquí está mi intento

Code para registrar todos los controladores de eventos de dominio ...

        var asm = Assembly.GetExecutingAssembly();
        var handlerType = typeof(IHandleDomainEvents<>);

        builder.RegisterAssemblyTypes(asm)
            .Where(t => handlerType.IsAssignableFrom(t)
                        && t.IsClass
                        && !t.IsAbstract)
            .AsClosedTypesOf(handlerType)
            .InstancePerLifetimeScope(); 

Y resolviendo todos los controladores de eventos en el despachador. El problema es que no se resuelven los controladores.

public class EventDispatcher : IEventDispatcher
{
    private readonly IContainer _container;

    public EventDispatcher(IContainer container)
    {
        _container = container;
    }

    public void Dispatch<TEvent>(TEvent eventToDispatch) where TEvent : IDomainEvent
    {
        var handlers = _container.Resolve<IEnumerable<IHandleDomainEvents<TEvent>>>().ToList();
        handlers.ForEach(handler => handler.Handle(eventToDispatch));
    }
}

Así que no estoy registrando los controladores de eventos correctamente o no los estoy resolviendo. ¿Cómo verifico que el registro esté funcionando?

Código de ejemplo de un controlador

public class SendWebQuestionToCSO : IHandleDomainEvents<JobNoteCreated>
{
    private readonly IConfig _config;

    public SendWebQuestionToCSO(IConfig config)
    {
        _config = config;
    } 

    public void Handle(JobNoteCreated args)
    {
        var jobNote = args.JobNote;
        using(var message = new MailMessage())
        {
            var client = new SmtpClient {Host = _config.SmtpHostIp};
            message.From = new MailAddress(_config.WhenSendingEmailFromWebProcessUseThisAddress);
            ...... etc
        }
    }
}

ACTUALIZA Después de alguna prueba y error, EventDispatcher funciona bien. Si registro manualmente un controlador y luego disparo el evento de dominio, funciona. El escaneo / registro del ensamblado es mi problema. El código de registro manual ...

builder.RegisterType<SendWebQuestionToCSO >().As<IHandleDomainEvents<JobNoteCreated>>();

Entonces, ¿cómo escaneo todos los ensamblajes para todosIHandleDomainEvents<> dado que se ven así

public class SendWebQuestionToCSO : IHandleDomainEvents<JobNoteCreated>