Message-based domain object collaboration

Recently, i was thinking about how to use message to implement the domain object collaboration. And now i have some thoughts:

1. Each domain object will implement an interface if it want to response one message;
2. Each domain object will not depend on any other domain objects, that means we will not have the Model.OtherModel relation;
3. Each domain object only do the things which only modify itself;
4. Each domain object can send a message, and this message will be received by any other domain objects which are care about this message;

Totally, the only way of collaboration between domain objects is message, one domain object can send any messages or receive any messages as long as it need.

When i learn Evans's DDD, i see that he defines the aggregate concept in domain, i think aggregate is static and not suitable for objects interactions, he only focused on the static structure of objects or relationship between objects. In real world, object will interact using messages, not by referencing each other or aggregating other objects. In my opinion, all the objects are equal, that means they will not depend on any other objects. For about how to implement the functionality of sending messages or receive messages, i think we can create a EventBus framework which is specially used for the collaboration of domain object. We can mapping t开发者_JS百科he event type to the subscriber type in a dictionary. The key is event type, the value is a list of subscriber types. When one event is raised, we can find the corresponding subscriber types, and get all the subscriber domain objects from data persistence and then call the corresponding handle methods on each subscriber.

For example:

public class EventA : IEvent { }
public class EventB : IEvent { }
public class EventC : IEvent { }

public class ExampleDomainObject : Entity<Guid>{
    public void MethodToRaiseAnExampleEvent()
    {
        RaiseEvent(new EventC());
    }
}
public class A : Entity<Guid>, IEventHandler<EventB>, IEventHandler<EventC> {
    public void Handle(EventB evnt)
    {
        //Response for EventB.
    }
    public void Handle(EventC evnt)
    {
        //Response for EventC.
    }
}
public class B : IEventHandler<EventA>, IEventHandler<EventC> {
    public void Handle(EventA evnt)
    {
        //Response for EventA.
    }
    public void Handle(EventC evnt)
    {
        //Response for EventC.
    }
}

That's my thoughts. Hopes to hear your words.

Have you ever heard of event sourcing or CQRS?

It sounds like that's the direction your thoughts are heading.

There's a lot of great info out there. Many good blog posts about CQRS and Domain Events, messaging-based domains.

Some example implementations are available, and there's a helpful and active community where implementation details can be discussed.