C # Обработка событий домена DDD с помощью динамически созданных обработчиков событий - PullRequest
0 голосов
/ 20 мая 2018

Я создаю приложение, используя ASP.NET Core 2.0 с EF Core 2.0.Что касается разделения различных видов логики в моем домене, я использую доменные события DDD (Domain Driven Design).Давайте углубимся в реализацию и посмотрим, что у меня есть, тогда я буду обсуждать мою проблему.Прежде всего, давайте посмотрим на общую реализацию моих классов, связанных с событиями домена.Во-первых, интерфейс маркера, IDomainEvent:

public interface IDomainEvent
{
}

Рядом с ним у меня есть общий IHandler класс:

public interface IHandler<in T> where T : IDomainEvent
{
    void Handle(T domainEvent);
}

Затем у меня есть DomainEvents класс:

private static List<Type> _handlers;

public static void Init()
{
    InitHandlersFromAssembly();
}

private static void InitHandlersFromAssembly()
{
    _handlers = Assembly.GetExecutingAssembly()
        .GetTypes()
        .Where(x => x.GetInterfaces().Any(y => y.IsGenericType && y.GetGenericTypeDefinition() == typeof(IHandler<>)))
        .ToList();
}

public static void Dispatch(IDomainEvent domainEvent)
{
    foreach (var handlerType in _handlers)
    {
        if (CanHandleEvent(handlerType, domainEvent))
        {
            dynamic handler = Activator.CreateInstance(handlerType);
            handler.Handle((dynamic)domainEvent);
        }
    }
}

private static bool CanHandleEvent(Type handlerType, IDomainEvent domainEvent)
{
    return handlerType.GetInterfaces()
        .Any(x => x.IsGenericType
                  && x.GetGenericTypeDefinition() == typeof(IHandler<>)
                  && x.GenericTypeArguments[0] == domainEvent.GetType());
}

Как видите, класс DomainEvents инициализирует все события домена исполняемой сборки.Метод Dispatch вызывается в переопределенном методе SaveChanges() моего пользовательского DbContext домена.Я вызываю диспетчеризацию здесь для того, чтобы отправлять все события в транзакции единицы работы:

public override int SaveChanges()
{
    DomainEventsDispatcher.Dispatch(ChangeTracker);

    return base.SaveChanges();
}

И реализация DomainEventDispatcher:

public static class DomainEventsDispatcher
{
    public static void Dispatch(ChangeTracker changeTracker)
    {
        var domainEvents = GetDomainEventEntities(changeTracker);

        HandleDomainEvents(domainEvents);
    }

    private static IEnumerable<IEntity> GetDomainEventEntities(ChangeTracker changeTracker)
    {
        return changeTracker.Entries<IEntity>()
            .Select(po => po.Entity)
            .Where(po => po.Events.Any())
            .ToArray();
    }

    private static void HandleDomainEvents(IEnumerable<IEntity> domainEventEntities)
    {
        foreach (var entity in domainEventEntities)
        {
            var events = entity.Events.ToArray();
            entity.Events.Clear();

            DispatchDomainEvents(events);
        }
    }

    private static void DispatchDomainEvents(IDomainEvent[] events)
    {
        foreach (var domainEvent in events)
        {
            DomainEvents.Dispatch(domainEvent);
        }
    }

ИтакНасколько хорошо, он довольно хорошо работает с простыми обработчиками событий домена, например:

public class OrderCreatedEventHandler : IHandler<OrderCreatedEvent>
{
    public void Handle(OrderCreatedEvent domainEvent)
    {
        Console.WriteLine("Order is created!");
    }
}

Но у меня есть некоторые другие обработчики событий, в которые я хотел бы внедрить некоторую зависимость, а именно Repository:

public class OrderCreatedEventHandler : IHandler<OrderCreatedEvent>
{
    private readonly IOrderHistoryRepository _orderHistoryRepository;

    public OrderCreatedEventHandler(IOrderHistoryRepository orderHistoryRepository)
    {
        _orderHistoryRepository = orderHistoryRepository;
    }

    public void Handle(OrderCreatedEvent domainEvent)
    {
        _orderHistoryRepository.Insert(new OrderHistoryLine(domainEvent));
    }
}

Моя проблема заключается в следующем: В DomainEvents class Dispatch метод я использую Activator class для динамического конструирования обработчиков событий во время выполнения.В этой строке выдается исключение со следующим сообщением:

System.MissingMethodException: 'No parameterless constructor defined for this object.'

Что логично, поскольку в OrderCreatedEventHandler имеется только один конструктор с внедренным хранилищем.Мой вопрос: возможно ли внедрить этот репозиторий в мой динамически сконструированный обработчик?Если нет, что может быть решением или обходным путем для моей проблемы?

Дополнительная информация:

В качестве платформы IoC я использую Autofac и настраиваю его в Startup.cs, где также инициализируются события домена:

    // This method gets called by the runtime. Use this method to add services to the container.
    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddMokaKukaTrackerDbContext(CurrentEnvironment, Configuration);
        services.RegisterIdentityFramework();
        services.AddAndConfigureMvc(CurrentEnvironment);

        var autofacServiceProvider = new AutofacServiceProvider(CreateIoCContainer(services));
        DomainEvents.Init();

        return autofacServiceProvider;
    }

    private static IContainer CreateIoCContainer(IServiceCollection services)
    {
        var builder = new ContainerBuilder();
        builder.Populate(services);
        builder.RegisterModule(new AutofacInjectorBootstrapperModule());

        return builder.Build();
    }

Если вам нужна дополнительная информация / код о моей проблеме, дайте мне знать, тогда я включу их как можно скорее.Заранее спасибо!

Ответы [ 2 ]

0 голосов
/ 24 мая 2018

Я решил разместить свое окончательное решение для проблемы, как @Devesh Tipe запросил его.Утвержденное решение решило мою проблему, но я провел несколько рефакторингов в моей кодовой базе, чтобы обработать события домена более элегантным способом.Следующее решение позволяет нам создавать обработчики доменов с зависимостями, которые разрешаются во время выполнения с помощью инфраструктуры зависимостей Autofac.Давайте погрузимся в код, включая все решение:

Прежде всего, у меня есть интерфейс маркера для событий домена:

public interface IDomainEvent
{
}

Затем у меня есть один интерфейс для обработчиков домена:

public interface IHandler<in T> where T : IDomainEvent
{
    void Handle(T domainEvent);
}

Кроме того, у меня есть EventDispatcher, который отвечает за отправку / обработку одного события:

public class EventDispatcher : IEventDispatcher
{
    private readonly ILifetimeScope _lifetimeScope;

    public EventDispatcher(ILifetimeScope lifetimeScope)
    {
        _lifetimeScope = lifetimeScope;
    }

    public void Dispatch<TEvent>(TEvent eventToDispatch) where TEvent : IDomainEvent
    {
        foreach (dynamic handler in GetHandlers(eventToDispatch))
        {
            handler.Handle((dynamic)eventToDispatch);
        }
    }

    private IEnumerable GetHandlers<TEvent>(TEvent eventToDispatch) where TEvent : IDomainEvent
    {
        return (IEnumerable) _lifetimeScope.Resolve(
            typeof(IEnumerable<>).MakeGenericType(
                typeof(IHandler<>).MakeGenericType(eventToDispatch.GetType())));
    }
}

Как видите, здесь соответствующие обработчики с их разрешенными зависимостями извлекаются и вызываются,Этот диспетчер используется в классе исполнителя, например:

public class DomainEventHandlingsExecutor : IDomainEventHandlingsExecutor
{
    private readonly IEventDispatcher _domainEventDispatcher;

    public DomainEventHandlingsExecutor(IEventDispatcher domainEventDispatcher)
    {
        _domainEventDispatcher = domainEventDispatcher;
    }

    public void Execute(IEnumerable<IEntity> domainEventEntities)
    {
        foreach (var entity in domainEventEntities)
        {
            var events = entity.Events.ToArray();
            entity.Events.Clear();

            foreach (var @event in events)
            {
                _domainEventDispatcher.Dispatch(@event);
            }
        }
    }
}

, который вводится в мой контекст БД:

    public MokaKukaTrackerDbContext(DbContextOptions<MokaKukaTrackerDbContext> options, IDomainEventHandlingsExecutor domainEventHandlingsExecutor) : base(options)
    {
        _domainEventHandlingsExecutor = domainEventHandlingsExecutor;
    }

    public override int SaveChanges()
    {
        var numberOfChanges = base.SaveChanges();

        _domainEventHandlingsExecutor.Execute(GetDomainEventEntities());

        return numberOfChanges;
    }

    private IEnumerable<IEntity> GetDomainEventEntities()
    {
        return ChangeTracker.Entries<IEntity>()
            .Select(po => po.Entity)
            .Where(po => po.Events.Any())
            .ToArray();
    }

Последнее, но не менее важное, что я сделал, и AutofacModule, где я регистрируюсьвсе обработчики и логики, относящиеся к обработке событий в домене:

public class AutofacEventHandlingBootstrapperModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<EventDispatcher>().As<IEventDispatcher>().InstancePerLifetimeScope();
        builder.RegisterType<DomainEventHandlingsExecutor>().As<IDomainEventHandlingsExecutor>().InstancePerLifetimeScope();

        RegisterEventHandlersFromDomainModel(builder);
    }

    private static void RegisterEventHandlersFromDomainModel(ContainerBuilder builder)
    {
        var domainModelExecutingAssembly = new DomainModelExecutingAssemblyGetter().Get();

        builder.RegisterAssemblyTypes(domainModelExecutingAssembly)
            .Where(t => t.GetInterfaces().Any(i => i.IsClosedTypeOf(typeof(IHandler<>))))
            .AsImplementedInterfaces()
            .InstancePerLifetimeScope();
    }
}

Что, конечно, должно быть зарегистрировано в Startup.cs:

   public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddMokaKukaTrackerDbContext(CurrentEnvironment, Configuration);

        return new AutofacServiceProvider(CreateIoCContainer(services));
    }

    private static IContainer CreateIoCContainer(IServiceCollection services)
    {
        var builder = new ContainerBuilder();
        builder.Populate(services);
        builder.RegisterModule(new AutofacInjectorBootstrapperModule());
        builder.RegisterModule(new AutofacEventHandlingBootstrapperModule());

        return builder.Build();
    }

Вот и все, надеюсь, это кому-нибудь поможет!

0 голосов
/ 21 мая 2018

Решением является использование контейнера внедрения зависимостей для создания экземпляров объектов с зависимостями.Для этого вам нужно передать IContainer в экземпляр DomainEvents, т.е. передать в качестве аргумента вызов метода DomainEvents.Init().

    // This method gets called by the runtime. Use this method to add services to the container.
    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddMokaKukaTrackerDbContext(CurrentEnvironment, Configuration);
        services.RegisterIdentityFramework();
        services.AddAndConfigureMvc(CurrentEnvironment);

        var container = CreateIoCContainer(services);
        var autofacServiceProvider = new AutofacServiceProvider(container);
        DomainEvents.Init(container);

        return autofacServiceProvider;
    }

Затем класс DomainEvents должен сохранитьссылка на container и использование его в методе Dispatch.

Примечание 1: У меня нет большого опыта работы с C #, поэтому я не уверен, что IContainer или IServiceProvider следует ввести в DomainEvents

Примечание 2: Как сказано в комментариях @TSeng, старайтесь не использовать статические методы;рефакторинг для использования экземпляров классов вместо.

...