📜 Event Sourcing

📖 What is Event Sourcing?

Event Sourcing is a design pattern where the state of an application is derived from a sequence of events rather than storing only the current state. Every change is captured as an immutable event and stored in an event store. The current state can be rebuilt by replaying these events.

🛠 Example in .NET Core

Here’s a simplified example of Event Sourcing for an Order Aggregate:

// Event definition
public abstract class Event
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public DateTime OccurredOn { get; set; } = DateTime.UtcNow;
}

public class OrderCreated : Event
{
    public string OrderId { get; set; }
    public string Customer { get; set; }
}

public class ItemAdded : Event
{
    public string OrderId { get; set; }
    public string Item { get; set; }
}

// Aggregate Root
public class Order
{
    public string OrderId { get; private set; }
    public string Customer { get; private set; }
    public List<string> Items { get; private set; } = new();
    public List<Event> Changes { get; private set; } = new();

    public static Order Create(string orderId, string customer)
    {
        var order = new Order();
        var @event = new OrderCreated { OrderId = orderId, Customer = customer };
        order.Apply(@event);
        order.Changes.Add(@event);
        return order;
    }

    public void AddItem(string item)
    {
        var @event = new ItemAdded { OrderId = this.OrderId, Item = item };
        Apply(@event);
        Changes.Add(@event);
    }

    private void Apply(OrderCreated e)
    {
        OrderId = e.OrderId;
        Customer = e.Customer;
    }

    private void Apply(ItemAdded e)
    {
        Items.Add(e.Item);
    }
}
    

✅ Advantages

• Complete audit log of all changes.
• Ability to rebuild state at any point in time.
• Supports event-driven architectures and CQRS.
• Enables temporal queries (e.g., “state as of yesterday”).

⚠️ Disadvantages

• Increased storage requirements (all events are stored).
• Complexity in designing event schemas and versioning.
• Replaying large event streams can be slow without snapshots.
• Requires careful handling of eventual consistency.

🧭 Best Practices

• Use snapshots to optimize rebuilding state from long event streams.
• Design immutable, versioned events to handle schema evolution.
• Combine with CQRS for separating read and write models.
• Use a reliable event store (EventStoreDB, Marten, Kafka, Cosmos DB).

🔒 Precautions

• Ensure event immutability — never modify past events.
• Plan for event schema evolution (backward compatibility).
• Secure event store with authentication and encryption.
• Monitor event replay performance and apply snapshots when needed.

🎯 Summary

Event Sourcing is a powerful pattern for building auditable, event-driven systems. In .NET Core, it can be implemented with custom code or libraries like EventStoreDB or Marten. While it adds complexity, it provides unmatched traceability, flexibility, and integration with CQRS.