aggregate-design

To implement an event-sourced aggregate root in .NET, use factory-based creation, private state setters, and typed Apply handlers. Route events using dynamic dispatch, validate event sequences, and track uncommitted events for persistence via a commit service.

Replay event history using a LoadFromHistory method that applies past events without marking them as new. This ensures historical state reconstruction remains separate from tracking uncommitted events meant for the commit service workflow.

Aggregate state uses private setters in event sourcing to enforce domain invariants and prevent external mutation. State changes must only occur through typed Apply handlers triggered by events, avoiding common anti-patterns like public setters or constructor-based creation.

Dynamic dispatch routes events to typed Apply handlers by using reflection or a dynamic method to match the event type at runtime. A generic Aggregate<T> base class applies this mechanism to automatically invoke the correct overload for each specific domain event.

You can use CQRS and DDD patterns with event-sourced aggregates in .NET. The aggregate design supports these patterns by encapsulating domain logic, enforcing invariants inside aggregate methods, and separating command handling from event persistence workflows.

Sequence validation rules for committing events require setting the aggregate Id on the first event and ensuring correct chronological ordering. The aggregate must validate sequences during ApplyChange operations before tracking and forwarding events to the commit service.