Event Sourcing Example & Explained in plain English

public interface IEvent {}

public record ProductShipped(string Sku, int Quantity, DateTime DateTime) : IEvent;

public record ProductReceived(string Sku, int Quantity, DateTime DateTime) : IEvent;

public record InventoryAdjusted(string Sku, int Quantity, string Reason, DateTime DateTime) : IEvent;

public class CurrentState { public int QuantityOnHand { get; set; } }

public class WarehouseProduct { public string Sku { get; } private readonly IList<IEvent> _allEvents = new List<IEvent>(); private readonly IList<IEvent> _uncommittedEvents = new List<IEvent>();

// Projection (Current State) private readonly CurrentState _currentState = new();

public WarehouseProduct(string sku) { Sku = sku; }

public void ShipProduct(int quantity) { if (quantity > _currentState.QuantityOnHand) { throw new InvalidDomainException("Ah... we don't have enough product to ship?"); }

AddEvent(new ProductShipped(Sku, quantity, DateTime.UtcNow)); }

public void ReceiveProduct(int quantity) { AddEvent(new ProductReceived(Sku, quantity, DateTime.UtcNow)); }

public void AdjustInventory(int quantity, string reason) { if (_currentState.QuantityOnHand + quantity < 0) { throw new InvalidDomainException("Cannot adjust to a negative quantity on hand."); }

AddEvent(new InventoryAdjusted(Sku, quantity, reason, DateTime.UtcNow)); }

private void Apply(ProductShipped evnt) { _currentState.QuantityOnHand -= evnt.Quantity; }

private void Apply(ProductReceived evnt) { _currentState.QuantityOnHand += evnt.Quantity; }

private void Apply(InventoryAdjusted evnt) { _currentState.QuantityOnHand += evnt.Quantity; }

public void ApplyEvent(IEvent evnt) { switch (evnt) { case ProductShipped shipProduct: Apply(shipProduct); break; case ProductReceived receiveProduct: Apply(receiveProduct); break; case InventoryAdjusted inventoryAdjusted: Apply(inventoryAdjusted); break; default: throw new InvalidOperationException("Unsupported Event."); }

_allEvents.Add(evnt); }

public void AddEvent(IEvent evnt) { ApplyEvent(evnt); _uncommittedEvents.Add(evnt); }

public IList<IEvent> GetUncommittedEvents() { return new List<IEvent>(_uncommittedEvents); }

public IList<IEvent> GetAllEvents() { return new List<IEvent>(_allEvents); }

public void EventsCommitted() { _uncommittedEvents.Clear(); }

public int GetQuantityOnHand() { return _currentState.QuantityOnHand; } }

public class InvalidDomainException : Exception { public InvalidDomainException(string message) : base(message) {

} }

public class WarehouseProductRepository { private readonly Dictionary<string, List<IEvent>> _inMemoryStreams = new();

public WarehouseProduct Get(string sku) { var warehouseProduct = new WarehouseProduct(sku);

if (_inMemoryStreams.ContainsKey(sku)) { foreach (var evnt in _inMemoryStreams[sku]) { warehouseProduct.ApplyEvent(evnt); } }

return warehouseProduct; }

public void Save(WarehouseProduct warehouseProduct) { if (_inMemoryStreams.ContainsKey(warehouseProduct.Sku) == false) { _inMemoryStreams.Add(warehouseProduct.Sku, new List<IEvent>()); }

var newEvents = warehouseProduct.GetUncommittedEvents(); _inMemoryStreams[warehouseProduct.Sku].AddRange(newEvents); warehouseProduct.EventsCommitted(); } }

var warehouseProduct = warehouseProductRepository.Get(sku); warehouseProduct.ReceiveProduct(quantity); warehouseProductRepository.Save(warehouseProduct);