gistlib - implement event sourcing for a basket in csharp

Event sourcing is an architectural pattern that is used to ensure that application state changes are captured as a sequence of domain-specific events that can be stored in durable storage. In this model, the current state of the application can be derived by replaying the events in sequence.

To implement event sourcing for a basket in C#, you can use the following steps:

Define the basket domain model: A Basket can contain several items, each with a quantity, and a total value of all items. You should create a class or interface that represents the Basket domain, and the events that can be raised by the basket domain.


main.cs
public class Basket
{
    public Guid Id { get; }
    public string CustomerId { get; private set; }
    public List<BasketItem> Items { get; private set; }
    public decimal TotalValue { get; private set; }

    // Constructor for creating a new basket
    public Basket(Guid id, string customerId)
    {
        Id = id;
        CustomerId = customerId;
        Items = new List<BasketItem>();
        TotalValue = 0;
    }

    // Method for adding a new item to the basket
    public void AddItem(BasketItem item)
    {
        Items.Add(item);
        TotalValue += item.Price * item.Quantity;
    }
}

public class BasketItem
{
    public Guid Id { get; }
    public string Name { get; }
    public decimal Price { get; }
    public int Quantity { get; }

    public BasketItem(Guid id, string name, decimal price, int quantity)
    {
        Id = id;
        Name = name;
        Price = price;
        Quantity = quantity;
    }
}

// Define the events that can be raised by the basket domain
public class BasketCreatedEvent
{
    public Basket Basket { get; }
    public BasketCreatedEvent(Basket basket)
    {
        Basket = basket;
    }
}

public class ItemAddedEvent
{
    public Guid BasketId { get; }
    public BasketItem Item { get; }
    public ItemAddedEvent(Guid basketId, BasketItem item)
    {
        BasketId = basketId;
        Item = item;
    }
}
1377 chars
61 lines

Create a class to represent the Basket repository: The repository will be responsible for persisting the domain events to a durable store (e.g., database). In this example, we will be using a simple in-memory store to keep things simple.


main.cs
public interface IBasketRepository
{
    void Save(Event[] events);
    Basket Get(Guid id);
}

public class InMemoryBasketRepository : IBasketRepository
{
    private readonly Dictionary<Guid, List<Event>> _eventStore = new Dictionary<Guid, List<Event>>();

    public void Save(Event[] events)
    {
        foreach (var @event in events)
        {
            if (!_eventStore.ContainsKey(@event.AggregateId))
            {
                _eventStore[@event.AggregateId] = new List<Event>();
            }

            _eventStore[@event.AggregateId].Add(@event);
        }
    }

    public Basket Get(Guid id)
    {
        if (!_eventStore.ContainsKey(id))
        {
            return null;
        }

        var events = _eventStore[id];

        // Rehydrate the basket object from the domain events
        var basket = new Basket(id, "test");
        foreach (var @event in events)
        {
            ApplyEvent(@event, basket);
        }

        return basket;
    }

    private void ApplyEvent(Event @event, Basket basket)
    {
        switch (@event)
        {
            case BasketCreatedEvent basketCreatedEvent:
                basket.Id = basketCreatedEvent.Basket.Id;
                break;
            case ItemAddedEvent itemAddedEvent:
                basket.AddItem(itemAddedEvent.Item);
                break;
        }
    }
}
1362 chars
56 lines

Raise the domain events when processing domain commands: Whenever a command is executed on the Basket domain (e.g., adding a new item), we will raise the corresponding event.


main.cs
public class BasketService
{
    private readonly IBasketRepository _basketRepository;

    public BasketService(IBasketRepository basketRepository)
    {
        _basketRepository = basketRepository;
    }

    public void AddItem(Guid basketId, BasketItem item)
    {
        var basket = _basketRepository.Get(basketId);
        if (basket == null)
        {
            throw new Exception("Basket not found");
        }

        var @event = new ItemAddedEvent(basketId, item);

        _basketRepository.Save(new[] { @event });
    }

    public Guid CreateBasket(string customerId)
    {
        var basket = new Basket(Guid.NewGuid(), customerId);
        var @event = new BasketCreatedEvent(basket);

        _basketRepository.Save(new[] { @event });
        return basket.Id;
    }
}
794 chars
32 lines

Query the current state of the Basket: Whenever we want to query the current state of the basket, we will first retrieve all events related to that basket from the repository, and then rehydrate the domain object from those events.


main.cs
var basketService = new BasketService(new InMemoryBasketRepository());

var basketId = basketService.CreateBasket("test");
basketService.AddItem(basketId, new BasketItem(Guid.NewGuid(), "Product 1", 10, 2));

var basket = basketService.GetBasket(basketId);

Console.WriteLine($"Basket total value: {basket.TotalValue}");
321 chars
9 lines

In conclusion, event sourcing can be a powerful pattern for building scalable and resilient systems, especially in scenarios where it's important to keep track of every state change in the system. However, implementing it requires careful modeling of the domain, as well as careful handling of events and rebuilding of the domain object.

implement event sourcing for a basket in csharp

similar csharp code snippets

related categories