Gdzie zgłaszać zdarzenia domeny zależne od trwałości-usługi, repozytorium lub interfejsu użytkownika?

Moim rozwiązaniem jest to, że podnosisz zdarzenia zarówno w warstwie domeny, jak i w warstwie usług.

Twoja domena:

public class Order
{
    public void ChangeStatus(OrderStatus status)
    {
        // change status
        this.Status = status;
        DomainEvent.Raise(new OrderStatusChanged { OrderId = Id, Status = status });
    }

    public void AddNote(string note)
    {
        // add note
        this.Notes.Add(note)
        DomainEvent.Raise(new NoteCreatedForOrder { OrderId = Id, Note = note });
    }
}

Twój serwis:

public class OrderService
{
    public void SubmitOrder(int orderId, OrderStatus status, string note)
    {
        OrderStatusChanged orderStatusChanged = null;
        NoteCreatedForOrder noteCreatedForOrder = null;

        DomainEvent.Register<OrderStatusChanged>(x => orderStatusChanged = x);
        DomainEvent.Register<NoteCreatedForOrder>(x => noteCreatedForOrder = x);

        using (var uow = UnitOfWork.Start())
        {
            var order = orderRepository.Load(orderId);
            order.ChangeStatus(status);
            order.AddNote(note);
            uow.Commit(); // commit to persist order
        }

        if (orderStatusChanged != null)
        {
            // something like this
            serviceBus.Publish(orderStatusChanged);
        }

        if (noteCreatedForOrder!= null)
        {
            // something like this
            serviceBus.Publish(noteCreatedForOrder);
        }
    }
}

Zdarzenia domeny powinny być podnoszone w... domena. Dlatego są to zdarzenia domenowe.

public void ExecuteCommand(MakeCustomerGoldCommand command)
{
    if (ValidateCommand(command) == ValidationResult.OK)
    {
        Customer item = CustomerRepository.GetById(command.CustomerId);
        item.Status = CustomerStatus.Gold;
        CustomerRepository.Update(item);
    }
}

(a następnie w klasie Klienta, następujące):

public CustomerStatus Status
{
    ....
    set
    {
        if (_status != value)
        {
            _status = value;
            switch(_status)
            {
                case CustomerStatus.Gold:
                    DomainEvents.Raise(CustomerIsMadeGold(this));
                    break;
                ...
            }
        }
    }

Metoda Raise zapisze Zdarzenie w magazynie zdarzeń. Może również wykonywać lokalnie zarejestrowane procedury obsługi zdarzeń.

Wygląda na to, że potrzebujesz warstwy serwisowej . Warstwa usług to kolejna abstrakcja, która znajduje się między interfejsem lub kontrolerami a warstwą biznesową lub modelem domeny. To coś w rodzaju API do Twojej aplikacji. Kontrolery będą wtedy miały dostęp tylko do warstwy usług.

public Order GetOrderById(int id) {
  //...
  var order = orderRepository.get(id);
  //...
  return order;
}

public CreateOrder(Order order) {
  //...
  orderRepositroy.Add(order);
  if (orderRepository.Submitchanges()) {
    var email = emailManager.CreateNewOrderEmail(order);
    email.Send();
  }
  //...
}

CzÄ™sto koÅ„czy siÄ™ na obiektach 'manager', takich jak OrderManager, aby współdziaÅ‚ać z zamówienia i warstwy usÅ‚ugowej do obsÅ‚ugi POCOs.

Czy odpowiednie jest, aby UI informowało o tych wydarzeniach? Wie, jakie zdarzenia miały miejsce i może je uruchomić dopiero po pomyślnym zapisaniu obiektu przez warstwę usług. Coś po prostu wydaje się nie tak z kontrolerem odpalającym zdarzenia domeny.

Powinien repozytorium odpala zdarzenia po pomyślnym utrzymaniu?

Czy jest na to lepszy sposób? Może aby obiekty mojej domeny ustawiały w kolejce zdarzenia, które są wywoływane przez warstwę usług dopiero po utrzymaniu obiektu?

Tak, wygląda na to, że powinno to być obsługiwane przez warstwę usług.

Posiadanie zdarzeń domeny działa dobrze, jeśli masz polecenia , wysłane do twojej warstwy usług . Następnie może aktualizować encje zgodnie z poleceniem i wywoływać odpowiednie zdarzenia domeny w pojedynczej transakcji.

Jeśli przenosisz same byty pomiędzy UI i service layer , bardzo trudno (a czasami nawet niemożliwe) jest określić, jakie zdarzenia w domenie miały miejsce, ponieważ nie są one jawne, ale ukryte pod state of the domain. / align = "left" /

Myślę, że powinieneś mieć usługę domenową, jak powiedział David Glenn.

Problem, na który wpadłem, polegał na tym, że warstwa usług skończy się na aby pobrać kopię niektórych obiektów przed zapisaniem zmodyfikowanej wersji do porównaj nowy z starym, a następnie zdecyduj, jakie wydarzenia powinien zostać zwolniony.

Usługa domeny powinna zawierać metody, które jasno określają, co chcesz zrobić z podmiotem domeny, takie jak: RegisterNewOrder, Createnoteforoorder, ChangeOrderStatus itp.

public class OrderDomainService()
{
    public void ChangeOrderStatus(Order order, OrderStatus status)
    {
        try
        {
            order.ChangeStatus(status);
            using(IUnitOfWork unitOfWork = unitOfWorkFactory.Get())
            {
                IOrderRepository repository = unitOfWork.GetRepository<IOrderRepository>();
                repository.Save(order);
                unitOfWork.Commit();
            }
            DomainEvents.Publish<OrderStatusChnaged>(new OrderStatusChangedEvent(order, status));
        }

    }
}