/// <summary>
/// Process a command through a command handler and aggregate root. Additional processing through event handlers and aggregates enrolled by process managers may
/// occur depending on how the domain engine is configured.
/// </summary>
/// <param name="command">The command to process.</param>
/// <returns>Any events gernerated as a result of processing the command.</returns>
public IEnumerable <IEvent> Process(ICommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
try
{
var resultingEvents = this.ProcessCommand(command);
this.DispatchEvents(resultingEvents);
this.EnqueueEvents(resultingEvents);
if (!this.domainOptions.Contains(DomainOption.CacheRuntimeModel))
{
this.runtimeModel.Clear();
}
transactionScope.Complete();
return(resultingEvents);
}
catch (Exception)
{
this.runtimeModel.Clear();
throw;
}
}
}
public IEnumerable <IEvent> BrokerEvent <TEvent>(IEvent <TEvent> domainEvent)
{
if (domainEvent == null)
{
throw new ArgumentNullException(nameof(domainEvent));
}
var results = new List <IEvent>();
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
var customEventHandlers = this.boundedContextModel.GetEventHandlerTypes(domainEvent.EventBody.GetType());
var commands = new List <ICommand>();
foreach (var eventHandlerType in customEventHandlers)
{
var eventHandlerId = this.boundedContextModel.EventHandlerModel(eventHandlerType).GetEventHandlerId(domainEvent);
commands.AddRange(this.eventHandler.Handle(domainEvent, eventHandlerId, eventHandlerType));
}
foreach (var command in commands)
{
results.AddRange(this.BrokerCommand(command.AsFullyTypedCommand(command.CommandBody)));
}
transactionScope.Complete();
}
return(results);
}
public void DispatchEvents(IEnumerable <IEvent> domainEvents)
{
if (domainEvents == null)
{
throw new ArgumentNullException(nameof(domainEvents));
}
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
domainEvents.ToList().ForEach(e => this.DispatchFullyTypedEvent(e.AsFullyTypedEvent(e.EventBody)));
transactionScope.Complete();
}
}
public void DispatchEvent(IEvent domainEvent)
{
if (domainEvent == null)
{
throw new ArgumentNullException(nameof(domainEvent));
}
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
this.DispatchFullyTypedEvent(domainEvent.AsFullyTypedEvent(domainEvent.EventBody));
transactionScope.Complete();
}
}
public void Store(string streamId, IEnumerable <IEvent> events)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (string.IsNullOrWhiteSpace(streamId))
{
throw new ArgumentNullException(nameof(streamId));
}
if (events.Count() == 0)
{
return;
}
events = events.OrderBy(e => e.AggregateVersion);
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
using (var eventStore = CreateEventContext())
{
var q = (from e in eventStore.Events
where e.StreamId == streamId
orderby e.Version descending
select new { ExpectedNextVersion = e.Version + 1, ExpectedAggregateType = e.StreamType });
var expectedValues = q.FirstOrDefault() ?? new { ExpectedNextVersion = 1, ExpectedAggregateType = events.First().AggregateType };
SqlEventStore.GuardStreamConcurency(events.First(), expectedValues.ExpectedNextVersion);
SqlEventStore.GuardEventArgregateTypes(events, expectedValues.ExpectedAggregateType);
SqlEventStore.GuardEventVersions(events, expectedValues.ExpectedNextVersion);
foreach (var item in events)
{
eventStore.Events.Add(ConvertEvent(streamId, item));
}
eventStore.SaveChanges();
}
transactionScope.Complete();
}
}
private IEnumerable <ICommand> ProcessEvent <TEvent>(IEvent <TEvent> domainEvent, string eventHandlerId, Type eventHandlerType)
{
IEnumerable <ICommand> resultingCommands;
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
resultingCommands = this.eventHandler.Handle(domainEvent, eventHandlerId, eventHandlerType);
if (!this.cacheRuntimeModel)
{
this.runtimeModel.Clear();
}
transactionScope.Complete();
}
return(resultingCommands);
}
public void Store <TAggregate>(string aggregateId, int aggregateVersion, TAggregate aggregate)
{
if (aggregate == null)
{
throw new ArgumentNullException(nameof(aggregate));
}
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
using (var context = CreateEventContext())
{
var existingSnapshot = context.Snapshots.Where(s => s.SnapshotId == aggregateId).FirstOrDefault();
if (existingSnapshot == null)
{
context.Snapshots.Add(new Snapshot()
{
SnapshotId = aggregateId,
CreatedBy = $"{Environment.UserDomainName}\\{Environment.UserName}",
CreatedUtc = DateTime.UtcNow,
SnapshotType = aggregate.GetType().FullName,
SnapshotData = snapshotSerialization.SerializeSnapshot(aggregate),
Version = aggregateVersion
});
}
else
{
existingSnapshot.CreatedBy = $"{Environment.UserDomainName}\\{Environment.UserName}";
existingSnapshot.CreatedUtc = DateTime.UtcNow;
existingSnapshot.SnapshotType = aggregate.GetType().FullName;
existingSnapshot.SnapshotData = snapshotSerialization.SerializeSnapshot(aggregate);
existingSnapshot.Version = aggregateVersion;
}
context.SaveChanges();
}
transactionScope.Complete();
}
}
public IEnumerable <IEvent> BrokerCommand <TCommand>(ICommand <TCommand> command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var results = new List <IEvent>();
using (var transactionScope = DomainTransaction.DefaultTransactionScope())
{
var events = this.commandHandler.HandleCommand(command, command.AggregateId, this.boundedContextModel.GetAggregateType(command.CommandBody.GetType()));
foreach (var @event in events)
{
results.Add(@event);
results.AddRange(this.BrokerEvent(@event.AsFullyTypedEvent(@event.EventBody)));
}
transactionScope.Complete();
}
return(results);
}