public override async Task LoadAsync(
IEventStore eventStore,
ISnapshotStore snapshotStore,
CancellationToken cancellationToken)
{
var snapshot = await snapshotStore.LoadSnapshotAsync <TAggregate, TIdentity, TSnapshot>(
Id,
cancellationToken)
.ConfigureAwait(false);
if (snapshot == null)
{
await base.LoadAsync(eventStore, snapshotStore, cancellationToken).ConfigureAwait(false);
return;
}
await LoadSnapshotContainerAsync(snapshot, cancellationToken).ConfigureAwait(false);
var domainEvents = await eventStore.LoadEventsAsync <TAggregate, TIdentity>(
Id,
snapshot.Metadata.AggregateSequenceNumber + 1,
cancellationToken)
.ConfigureAwait(false);
if (!domainEvents.Any())
{
Version = snapshot.Metadata.AggregateSequenceNumber;
return;
}
ApplyEvents(domainEvents);
}
public async Task <Order> LoadOrder(Guid id)
{
// You could add logic here to make sure you are only getting items you should
// for instance if you restrict access by tenantId, take in a TenantId parameter and
// only return if the tenantId matches.
if (_snapshotStore != null)
{
var snapshotStreamId = $"Order:{id}";
var snapshot = await _snapshotStore.LoadSnapshotAsync(snapshotStreamId);
if (snapshot != null)
{
var streamTail = await _eventStore.LoadStreamAsync(id.ToString(), snapshot.Version + 1);
var orderSnapshot = snapshot.SnapshotData.ToObject <OrderSnapshot>();
return(new Order(
orderSnapshot,
streamTail.Events));
}
}
var stream = await _eventStore.LoadStreamAsyncOrThrowNotFound(id.ToString());
return(new Order(stream.Events));
}
public async Task <TAggregateRoot> GetByIdAsync(object id, CancellationToken cancellationToken = default)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var aggregateLoaded = false;
var aggregate = new TAggregateRoot();//lots of ways to do this
var streamId = aggregate.GetStreamFor(id);
if (aggregate is ISnapshotableEntity snapshotableAggregate)
{
var snapshotEnvelope = await _snapshotStore.LoadSnapshotAsync(streamId, cancellationToken);
if (snapshotEnvelope != null)
{
snapshotableAggregate.ApplySnapshot(snapshotEnvelope.Snapshot, snapshotEnvelope.AggregateVersion);
aggregateLoaded = true;
}
}
var e = await _eventStore.GetEventsFromStreamAsync(streamId, aggregate.Version + 1, cancellationToken);
if (e.Any())
{
var events = e;
aggregate.LoadFromHistory(events);
aggregateLoaded = true;
}
stopWatch.Stop();
_logger.LogDebug("EventSourcedRepository.GetByIdAsync for {AggregateRootType} took {ElapsedMilliseconds} ms.", typeof(TAggregateRoot).Name, stopWatch.ElapsedMilliseconds);
return(aggregateLoaded ? aggregate : null);
}
public async Task <Meter> LoadMeterAsync(string id)
{
var streamId = $"meter:{id}";
var snapshot = await _snapshotStore.LoadSnapshotAsync(streamId);
if (snapshot != null)
{
var streamTail = await _eventStore.LoadStreamAsync(streamId, snapshot.Version + 1);
return(new Meter(
snapshot.SnapshotData.ToObject <MeterSnapshot>(),
snapshot.Version,
streamTail.Events));
}
else
{
return(await _innerMeterRepository.LoadMeterAsync(id));
}
}
