//Command的处理
public void AddHandlerFor <TCommand, TAggregate>() where TAggregate : Aggregate, new()
{
if (commandHandlers.ContainsKey(typeof(TCommand)))
{
throw new Exception($"Command handler already registered for {typeof(TCommand).Name}");
}
commandHandlers.Add(typeof(TCommand), c => {
var agg = new TAggregate();
agg.Id = ((dynamic)c).Id;
agg.ApplyEvents(eventStore.LoadEventsFor <TAggregate>(agg.Id)); //领域执行所有事件
var resultEvents = new List <Event>(); //所有执行的事件
foreach (var e in (agg as IHandleCommand <TCommand>).Handle((TCommand)c))
{
resultEvents.Add(e);
}
if (resultEvents.Count > 0)
{
eventStore.SaveEventsFor <TAggregate>(agg.Id, agg.EventsLoaded, resultEvents);//保存事件
}
foreach (var e in resultEvents)
{
PublishEvent(e);//发布事件
}
});
}
public TAggregate GetNew <TAggregate>() where TAggregate : class, IAggregateRoot, new()
{
var model = new TAggregate {
Context = _context, Version = -1
};
return(model);
}
public LeafwardNode(KeyVal data, bool isRed, LeafwardNode left, LeafwardNode right, Func <TAggregate, TKey, TVal, TAggregate, TAggregate> aggregator)
{
this.Data = data;
this.Left = left;
this.Right = right;
this.IsRed = isRed;
this.Aggregate = data == null ? default(TAggregate) : aggregator(left.Aggregate, data.Key, data.Val, right.Aggregate);
this.Count = data == null ? 0 : left.Count + 1 + right.Count;
}
public void SetNewVersion(TAggregate aggregate)
{
if (this.CurrentVersion != null)
{
this.History.Push(this.CurrentVersion);
aggregate.Version++;
}
else
{
this.Id = aggregate.Id;
aggregate.Version = 1;
}
this.CurrentVersion = aggregate;
}
/// <summary>
/// Registers an aggregate as being the handler for a particular
/// command.
/// </summary>
/// <typeparam name="TAggregate"></typeparam>
/// <param name="handler"></param>
public void AddHandlerFor <TCommand, TAggregate>()
where TAggregate : Aggregate, new()
{
if (commandHandlers.ContainsKey(typeof(TCommand)))
{
throw new Exception("Command handler already registered for " + typeof(TCommand).Name);
}
commandHandlers.Add(typeof(TCommand), command =>
{
// Create an empty aggregate.
var aggregate = new TAggregate();
aggregate.Id = ((dynamic)command).Id;
// Get all events for this aggregate and apply to aggregate
// to get to current state.
var allEvents = eventStore.LoadEventsFor <TAggregate>(aggregate.Id);
aggregate.ApplyEvents(allEvents);
// Call Handle(command) on all aggregates to yield the event (to store).
var resultEvents = new List <IEvent>();
foreach (var @event in ((IHandleCommand <TCommand>)aggregate).Handle((TCommand)command))
{
resultEvents.Add((IEvent)@event);
}
if (resultEvents.Count == 0)
{
return;
}
// Store the events in the event store.
eventStore.SaveEventsFor <TAggregate>(aggregate.Id, aggregate.EventsLoaded, resultEvents);
// We are done! trailer booked... but...
// ...publish events to subscribers.
foreach (var @event in resultEvents)
{
PublishEvent(@event);
}
});
}
/// <summary>
/// Registers an aggregate as being the handler for a particular
/// command.
/// </summary>
/// <typeparam name="TAggregate"></typeparam>
/// <typeparam name="TCommand"></typeparam>
public void AddHandlerFor <TCommand, TAggregate>() where TAggregate : IAggregate, new()
{
if (_commandHandlers.ContainsKey(typeof(TCommand)))
{
throw new Exception("Command handler already registered for " + typeof(TCommand).Name);
}
_commandHandlers.Add(typeof(TCommand), c =>
{
// Create an empty aggregate.
var agg = new TAggregate();
// Load the aggregate with events.
agg.Id = ((dynamic)c).Id;
agg.ApplyEvents(_eventStore.LoadEventsFor <TAggregate>(agg.Id));
// With everything set up, we invoke the command handler, collecting the
// events that it produces.
var resultEvents = new ArrayList();
var handleCommand = agg as IHandleCommand <TCommand>;
if (handleCommand != null)
{
foreach (var e in handleCommand.Handle((TCommand)c))
{
resultEvents.Add(e);
}
}
// Store the events in the event store.
if (resultEvents.Count > 0)
{
_eventStore.SaveEventsFor <TAggregate>(agg.Id, agg.Version, resultEvents);
}
// Publish them to all subscribers.
foreach (var e in resultEvents)
{
PublishEvent(e);
}
});
}
/// <summary>
/// Registers an aggregate as being the handler for a particular
/// command.
/// </summary>
/// <typeparam name="TAggregate"></typeparam>
/// <param name="handler"></param>
public void AddHandlerFor <TCommand, TAggregate>()
where TAggregate : Aggregate, IHandleCommand <TCommand>, new()
where TCommand : ICommand
{
if (commandHandlers.ContainsKey(typeof(TCommand)))
{
throw new Exception("Command handler already registered for " + typeof(TCommand).Name);
}
commandHandlers.Add(typeof(TCommand), c =>
{
// Create an empty aggregate.
var agg = new TAggregate();
// Load the aggregate with events.
agg.Id = c.Id;
agg.ApplyEvents(eventStore.LoadEventsFor <TAggregate>(agg.Id));
// With everything set up, we invoke the command handler, collecting the
// events that it produces.
var resultEvents = new List <IEvent>();
foreach (var e in agg.Handle((TCommand)c))
{
resultEvents.Add(e);
}
// Store the events in the event store.
if (resultEvents.Count > 0)
{
eventStore.SaveEventsFor <TAggregate>(agg.Id,
agg.EventsLoaded, resultEvents);
}
// Publish them to all subscribers.
foreach (var e in resultEvents)
{
PublishEvent(e);
}
});
}
internal static Entry AddedInMemory(TAggregate aggregate) => new Entry(aggregate, EntryState.Added);
internal static Entry LoadedFromDatabase(TAggregate aggregate) => new Entry(aggregate, EntryState.Loaded);
private Entry(TAggregate aggregate, EntryState state)
{
Aggregate = aggregate;
State = state;
}
