public AggregateRoot Get <TAggregateRoot>(string aggregateRootId, IUnitOfWork unitOfWork, long maxGlobalSequenceNumber = long.MaxValue, bool createIfNotExists = false)
{
if (!EnabledFor <TAggregateRoot>())
{
return(_aggregateRootRepository.Get <TAggregateRoot>(aggregateRootId, unitOfWork, maxGlobalSequenceNumber, createIfNotExists));
}
var snapshot = _snapshotStore.LoadSnapshot <TAggregateRoot>(aggregateRootId, maxGlobalSequenceNumber);
if (snapshot == null)
{
var aggregateRootInstance = _aggregateRootRepository.Get <TAggregateRoot>(aggregateRootId, unitOfWork, maxGlobalSequenceNumber, createIfNotExists);
var checkedOutSequenceNumber = new AggregateRootInfo(aggregateRootInstance).SequenceNumber;
if (maxGlobalSequenceNumber != long.MaxValue)
{
_snapshotStore.SaveSnapshot <TAggregateRoot>(aggregateRootId, aggregateRootInstance, maxGlobalSequenceNumber);
}
OnCommitted <TAggregateRoot>(aggregateRootId, unitOfWork, aggregateRootInstance, checkedOutSequenceNumber);
return(aggregateRootInstance);
}
var preparedInstance = PrepareFromSnapshot <TAggregateRoot>(snapshot, maxGlobalSequenceNumber, unitOfWork, aggregateRootId);
var sequenceNumberOfPreparedInstance = new AggregateRootInfo(preparedInstance).SequenceNumber;
OnCommitted <TAggregateRoot>(aggregateRootId, unitOfWork, preparedInstance, sequenceNumberOfPreparedInstance);
return(preparedInstance);
}
private void TryCreateCreateSnapshot(AggregateRoot savedInstance)
{
if (_snapshottingPolicy.ShouldCreateSnapshot(savedInstance))
{
var snapshot = _domainRepository.TryTakeSnapshot(savedInstance);
if (snapshot != null)
{
_snapshotStore.SaveSnapshot(snapshot);
}
}
}
public override async Task Save(TAggregate aggregate)
{
await base.Save(aggregate);
int currentVersion = aggregate.Version;
if (currentVersion > 0 && currentVersion % _interval == 0)
{
AggregateSnapshot snapshot = aggregate.MakeSnapshot();
await _snapshotStore.SaveSnapshot(snapshot);
}
}
public void Handle(T @event)
{
if (@event.Version % settings.WhenVersionNumberIsDividedBy != 0)
{
return;
}
var aggregate = eventStoreService.LoadAggregate(@event.AggregateId, GetAggregateTypeFromEvent(@event));
var snapshot = BuildSnapshotFromAggregate(aggregate);
snapshotStore.SaveSnapshot(snapshot);
Console.WriteLine($"{@event.AggregateId} Version: {@event.Version} snapshotted");
}
public async Task <IReadOnlyCollection <IAggregateEvent> > Execute(ICommand command)
{
var aggregate = await LoadAggregate(command);
var events = await aggregate.Execute(command);
await _eventStore.SaveEvents(command.Id, events);
//after event persistence we must be tolerant to any snapshot persistence failure
if (aggregate is ISupportSnapshots currentAggregate)
{
var snapshot = currentAggregate.BuildSnapshot();
await _snapshotStore.SaveSnapshot(snapshot);
}
return(events);
}
/// <summary>
/// Creates a new snapshot for the aggregate of type <paramref name="aggregateType" /> with id
/// <paramref name="aggregateId" />
/// </summary>
/// <param name="aggregateId">The Id of an aggregate</param>
/// <param name="aggregateType">The type of an aggregate</param>
public void CreateSnapshot(Guid aggregateId, Type aggregateType)
{
//Check if snapshotting is supported
ISnapshotableRepository repository;
_repositories.TryGetValue(aggregateType, out repository);
var originator = repository?.GetOriginator(aggregateId);
if (originator == null || originator.OriginatorId == Guid.Empty)
{
return;
}
using (new TimeMeasure(ms => _performanceMeasurementService.CountSnapshot()))
{
_snapshotStore.SaveSnapshot(originator);
}
}
private void SaveSnapshot(AggregateRoot aggregateRoot)
{
var snapshotOriginator = aggregateRoot as ISnapshotOriginator;
if (snapshotOriginator == null)
{
return;
}
var previousSnapshot = snapshotStore.GetSnapshot(aggregateRoot.Id);
if (!snapshotOriginator.ShouldTakeSnapshot(previousSnapshot))
{
return;
}
var snapshot = snapshotOriginator.GetSnapshot();
snapshot.AggregateRootId = aggregateRoot.Id;
snapshot.LastEventSequence = aggregateRoot.LastEventSequence;
snapshotStore.SaveSnapshot(snapshot);
}
