Event sourcing: fusione della radice e della proiezione aggregate?

Sto cercando di capire come funziona l'architettura basata su eventi.

Dalla mia comprensione, la proiezione è la rappresentazione di uno stato in un dato momento; infatti - è un'aggregazione di eventi che ha portato a quello stato. La proiezione viene archiviata in un archivio dati per finalità di interrogazione.

Dal momento che sia l'aggregato che la proiezione vengono "ricostruiti" dal flusso di eventi, perché non dovrei unirli in un pezzo di codice singolo?

Mi ritroverei con una classe che sarebbe responsabile di:

• aggiornando lo stato (interno) in base agli eventi applicati
• creazione di nuovi eventi quando viene chiesto di cambiare il suo stato

Ad esempio: l'ordine del negozio. Supponendo di disporre di un'infrastruttura che memorizza gli eventi e li invia alle proiezioni, quindi memorizza le proiezioni

class Order: Aggregate {
    private Guid _id;
    private OrderState _state;
    private DateTime _dateCreated;
    private List<Item> _items = new List<Item>();

    public Order()
    {
        // used when loading from projection data store (de-serializing from JSON for example)
    }

    public Order(Guid id, IEnumerable<Item> items)
    { 
        // used when handling CreateOrder command,
        // uses Aggregate.PublishEvent which appends the event to the stream
        // the event dispatcher causes the event to be Applied as well
        this.PublishEvent(new OrderCreated(id, items));
    }

    public void Apply(OrderCreated ev) 
    {
        // event applied by event dispatcher, when reconstructing from events
        this._id = ev.Id;
        this._state = OrderState.New;
        this._items = new List<Item>(ev.Items);
    }

    public void Ship()
    {
        // used when handling ShipOrder command
        // incorporates business logic
        if (this._state != OrderState.Shipped)
        {
            this.PublishEvent(new OrderShipped(this._id));
        }
    }
}