public void PersistUpdateOf(IAggregateRoot entity) { Account account = entity as Account; string sql = "UPDATE Account SET Balance=@Balance WHERE Id=@Id"; SqlParameter parameter1 = new SqlParameter("@Id", account.Id); SqlParameter parameter2= new SqlParameter("@Balance", account.Balance); using (SqlConnection conn = new SqlConnection(_connStr)) { conn.Open(); using (SqlCommand cmd = conn.CreateCommand()) { cmd.CommandText = sql; cmd.Parameters.Add(parameter1); cmd.Parameters.Add(parameter2); int affectedCount = cmd.ExecuteNonQuery(); if (affectedCount <= 0) { throw new Exception("update Account failed"); } } } }
public UserSnapshot(IAggregateRoot root, string name, int age) { Id = root.Id; Version = root.Version; Name = name; Age = age; }
public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository) { if (!addedEntities.ContainsKey(entity)) { addedEntities.Add(entity, unitOfWorkRepository); } }
public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository) { if (!deletedEntities.ContainsKey(entity)) { deletedEntities.Add(entity, unitOfWorkRepository); } }
public void RegisterAmended(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository) { if (!changedEntities.ContainsKey(objectEntity)) { changedEntities.Add(objectEntity, unitOfWorkRepository); } }
public void Add(IAggregateRoot entity, IUnitOfWorkRepository uowRepository) { if (!_addedEntities.ContainsKey(entity)) { _addedEntities.Add(entity, uowRepository); } }
public void RegisterUpdate(IAggregateRoot aggregateRoot, IUnitOfWorkRepository repository) { if (!_updatedAggregates.ContainsKey(aggregateRoot)) { _updatedAggregates.Add(aggregateRoot, repository); } }
/// <summary> /// Initializes a new instance of the <see cref="AggregateChangedEventArgs"/> class. /// </summary> /// <param name="aggregateRoot">The aggregate root.</param> /// <param name="entity">The entity.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="oldValue">The old value.</param> /// <param name="newValue">The new value.</param> public AggregateChangedEventArgs( IAggregateRoot aggregateRoot, IEntity entity, string propertyName, object oldValue, object newValue ) { if ( aggregateRoot == null ) { throw new ArgumentNullException ( "aggregateRoot" ); } if ( entity == null ) { throw new ArgumentNullException ( "entity" ); } if ( string.IsNullOrWhiteSpace ( propertyName ) ) { throw new ArgumentNullException ( "propertyName" ); } AggregateChangedType = AggregateChangedType.PropertyValueChanged; AggregateRoot = aggregateRoot; SourceEntity = entity; PropertyName = propertyName; OldValue = oldValue; NewValue = newValue; }
public void Add(IAggregateRoot aggregateRoot) { if (!_aggregateRoots.ContainsKey(aggregateRoot.AggregateRootId)) { _aggregateRoots.TryAdd(aggregateRoot.AggregateRootId, aggregateRoot); } }
public void RegisterDeletion(IAggregateRoot aggregateRoot, IUnitOfWorkRepository repository) { if (!_deletedAggregates.ContainsKey(aggregateRoot)) { _deletedAggregates.Add(aggregateRoot, repository); } }
public void RegisterRemoved(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository) { if (!removedEntities.ContainsKey(objectEntity)) { removedEntities.Add(objectEntity, unitOfWorkRepository); } }
public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository repository) { List<IAggregateRoot> items = null; if (!add.TryGetValue(repository, out items)) { items = new List<IAggregateRoot>(); add.Add(repository, items); } items.Add(entity); }
private EventStreamRecord BuildEventStream(IAggregateRoot aggregateRoot, string commandId) { return new EventStreamRecord() { AggregateRootId = aggregateRoot.AggregateRootId, CommandId = commandId, Version = aggregateRoot.Version, EventDatas = _binarySerializer.Serialize(aggregateRoot.GetUnCommitEvents()) }; }
public void Handle(IAggregateRoot root, IDomainEvent ev) { MethodInvoker invoker; if (!_handlers.TryGetValue(ev.GetType(), out invoker)) { throw new InvalidOperationException(string.Format("Apply method for event [{0}] wasn't resolved in [{1}]", ev.GetType().Name, root.GetType().Name)); } invoker.Invoke(root, new object[] {ev}); }
private DomainEventStreamMessage CreateMessage(IAggregateRoot aggregateRoot) { return new DomainEventStreamMessage( ObjectId.GenerateNewStringId(), aggregateRoot.UniqueId, aggregateRoot.Version + 1, aggregateRoot.GetType().FullName, aggregateRoot.GetChanges(), new Dictionary<string, string>()); }
public void Store(IDocumentSession session, IAggregateRoot root) { if (ShouldPersistSnapshot(root)) { StoreSnapshot(session, root); SetRecentSnaphotVersion(session, root); } else { StoreEvents(session, root); } }
public Snapshot CreateSnapshot(IAggregateRoot aggregateRoot) { if (aggregateRoot == null) { throw new ArgumentNullException("aggregateRoot"); } var payload = _binarySerializer.Serialize(aggregateRoot); var aggregateRootTypeCode = _aggregateRootTypeCodeProvider.GetTypeCode(aggregateRoot.GetType()); return new Snapshot(aggregateRootTypeCode, aggregateRoot.UniqueId, aggregateRoot.Version, payload, DateTime.Now); }
private static string CreateMessage(IAggregateRoot aggRoot, ICommand c, Exception ex) { var msg = "The action you were trying to perform succeeded, however not all systems have been updated yet."; msg += Environment.NewLine; msg += Environment.NewLine; msg += "Aggregate ID: " + aggRoot.AggregateId.ToString(); msg += Environment.NewLine; msg += "Command ID: " + c.CommandId.ToString(); msg += Environment.NewLine; msg += "Exception: " + ex.GetType().Name + " - " + ex.Message; return msg; }
internal static void Apply(IAggregateRoot root, IDomainEvent ev) { var rootType = root.GetType(); EventHandlerRegistry registry; if (!_handlers.TryGetValue(rootType, out registry)) { registry = new EventHandlerRegistry(ApplyMethodResolver.ResolveAll(rootType)); _handlers[rootType] = registry; } registry.Handle(root, ev); //ResolveApplyMethodDelegate(root.GetType(), ev.GetType())(root, ev); }
public void RegisterAdd(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository) { if (_ItemQueue == null) _ItemQueue = new Queue<UnitItem>(); UnitItem unitItem=new UnitItem() { Entity = entity, UnitOfWorkRepository = unitOfWorkRepository, Operator = UnitOperator.Add }; if (_ItemQueue.Contains(unitItem)) { throw new Exception("exist Entity in RegistorAdd!"); } else { _ItemQueue.Enqueue(unitItem); } }
private static string CreateMessage(IAggregateRoot aggRoot, Guid originalVersion, Guid currentVersion) { var aggType = aggRoot.GetType().Name; var msg = string.Format("The {0} you were trying to save has been updated by another user, you will have to start the editing process again to retry.", aggType); msg += Environment.NewLine; msg += Environment.NewLine; msg += "Aggregate ID: " + aggRoot.AggregateId.ToString(); msg += Environment.NewLine; msg += "Original Version: " + originalVersion.ToString(); msg += Environment.NewLine; msg += "Current Version: " + currentVersion.ToString(); return msg; }
/// <summary> /// Initializes a new instance of the <see cref="AggregateChangedEventArgs"/> class. /// </summary> /// <param name="aggregateRoot">The aggregate root.</param> /// <param name="entity">The entity.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="aggregateChangedType">Type of the aggregate changed.</param> /// <param name="collectionItem">The collection item.</param> public AggregateChangedEventArgs( IAggregateRoot aggregateRoot, IEntity entity, string propertyName, AggregateChangedType aggregateChangedType, object collectionItem ) { if ( aggregateRoot == null ) { throw new ArgumentNullException ( "aggregateRoot" ); } if ( entity == null ) { throw new ArgumentNullException ( "entity" ); } if ( string.IsNullOrWhiteSpace ( propertyName ) ) { throw new ArgumentNullException ( "propertyName" ); } if ( aggregateChangedType == AggregateChangedType.PropertyValueChanged ) { throw new ArgumentException ( "This constructor is for collection changes only." ); } if ( collectionItem == null ) { throw new ArgumentNullException ( "collectionItem" ); } AggregateChangedType = aggregateChangedType; AggregateRoot = aggregateRoot; SourceEntity = entity; PropertyName = propertyName; if ( AggregateChangedType == AggregateChangedType.CollectionItemAdded ) { NewValue = collectionItem; } else { OldValue = collectionItem; } }
public void ReplayEvents(IAggregateRoot aggregateRoot, IEnumerable<EventStream> eventStreams) { foreach (var eventStream in eventStreams) { VerifyEvent(aggregateRoot, eventStream); if (aggregateRoot.UniqueId == null && eventStream.Version == 1L) { aggregateRoot.UniqueId = eventStream.AggregateRootId; } foreach (var evnt in eventStream.Events) { HandleEvent(aggregateRoot, evnt); } IncreaseAggregateVersion(aggregateRoot); if (aggregateRoot.Version != eventStream.Version) { throw new ENodeException("Aggregate root version mismatch, aggregateId:{0}, current version:{1}, expected version:{2}", aggregateRoot.UniqueId, aggregateRoot.Version, eventStream.Version); } } }
private bool TryGetFromSnapshot(string aggregateRootId, Type aggregateRootType, out IAggregateRoot aggregateRoot) { aggregateRoot = null; var snapshot = _snapshotStore.GetLastestSnapshot(aggregateRootId, aggregateRootType); if (snapshot == null) return false; aggregateRoot = _snapshotter.RestoreFromSnapshot(snapshot); if (aggregateRoot == null) return false; if (aggregateRoot.UniqueId != aggregateRootId) { throw new Exception(string.Format("Aggregate root restored from snapshot not valid as the aggregate root id not matched. Snapshot aggregate root id:{0}, expected aggregate root id:{1}", aggregateRoot.UniqueId, aggregateRootId)); } var aggregateRootTypeCode = _aggregateRootTypeCodeProvider.GetTypeCode(aggregateRootType); var eventStreamsAfterSnapshot = _eventStore.QueryAggregateEvents(aggregateRootId, aggregateRootTypeCode, snapshot.Version + 1, int.MaxValue); aggregateRoot.ReplayEvents(eventStreamsAfterSnapshot); return true; }
public void PersistUncommitedEvents(IAggregateRoot aggregate) { try { persistenceManager.ExecuteNonQuery( "INSERT INTO [Events] (Id, aggregate_id, version, data) VALUES (@Id, @AggregateId, @Version, @Data)", new { Id = Guid.NewGuid(), Version = aggregate.Version + 1, AggregateId = aggregate.Id, Data = Serialize(aggregate.UncommitedEvents) }); } catch (SqlException se) { // Thanks Jonathan Oliver's CQRS Event Store if (se.Number == UniqueKeyViolation) throw new ConcurrencyException(); throw; } }
private bool TryGetFromSnapshot(string aggregateRootId, Type aggregateRootType, out IAggregateRoot aggregateRoot) { aggregateRoot = _aggregateSnapshotter.RestoreFromSnapshot(aggregateRootType, aggregateRootId); if (aggregateRoot == null) return false; if (aggregateRoot.GetType() != aggregateRootType || aggregateRoot.UniqueId != aggregateRootId) { throw new Exception(string.Format("AggregateRoot recovery from snapshot is invalid as the aggregateRootType or aggregateRootId is not matched. Snapshot: [aggregateRootType:{0},aggregateRootId:{1}], expected: [aggregateRootType:{2},aggregateRootId:{3}]", aggregateRoot.GetType(), aggregateRoot.UniqueId, aggregateRootType, aggregateRootId)); } var aggregateRootTypeName = _typeNameProvider.GetTypeName(aggregateRootType); var eventStreamsAfterSnapshot = _eventStore.QueryAggregateEvents(aggregateRootId, aggregateRootTypeName, aggregateRoot.Version + 1, int.MaxValue); aggregateRoot.ReplayEvents(eventStreamsAfterSnapshot); return true; }
public Entity(SerializationInfo info, StreamingContext context) { _root = (IAggregateRoot)info.GetValue("_root", typeof(IAggregateRoot)); _state = (TEntityState)info.GetValue("_state", typeof(TEntityState)); }
public void RegisterForTracking(IAggregateRoot aggregatedRoot) { _objectsTracked.Add(aggregatedRoot); }
public void PersistDeletionOf(IAggregateRoot entity) { this.Remove((TZ)entity); }
protected void RegisterUpdated(IAggregateRoot obj) { DataContext.Current.RegisterUpdated(obj, this); }
public static List <IDomainEvent> GetAllDomainEvents(IAggregateRoot aggregate) { return(GetAllDomainEvents(aggregate as Entity)); }
public RepositoryPrePersistEventArgs(IAggregateRoot target, RepositoryAction action) { this.Target = target; this.Action = action; this.Allow = true; //默认是允许执行后续操作的 }
public void PersistUpdateOf(IAggregateRoot entity) { Book updatedBook = _bookMapper.ToDocument((Core.Entities.Book)entity); _books.ReplaceOne(book => book.Id == updatedBook.Id, updatedBook); }
public ChildEntity(IAggregateRoot aggregateRoot, IEnumerable <IChildEntityEvent> events) : base(aggregateRoot, events) { }
public ChildEntity(IAggregateRoot aggregateRoot, ChildEntityId id, string name) : base(aggregateRoot, new ChildCreated((ParentEntityId)aggregateRoot.Id, id, name, DateTime.UtcNow)) { }
public AggregateCacheInfo(IAggregateRoot aggregateRoot) { AggregateRoot = aggregateRoot; LastUpdateTime = DateTime.Now; }
private static bool ShouldPersistSnapshot(IAggregateRoot root) { return(root.Version % 3 == 1); }
public void Set(IAggregateRoot aggregateRoot) { SetInternal(aggregateRoot); }
public void PersistUpdateOf(IAggregateRoot root) { throw new NotImplementedException(); }
public TestChildEntity(IAggregateRoot aggregateRoot, string id, string name) : base(aggregateRoot, new TestEntityChildAdded((string)aggregateRoot.Id, id, name)) { }
public void PersistDeletionOf(IAggregateRoot entity) { Book bookToDelete = _bookMapper.ToDocument((Core.Entities.Book)entity); _books.DeleteOne(book => book.Id == bookToDelete.Id); }
public EventProviderDescriptor(IAggregateRoot aggregateRoot) { Contract.Requires(aggregateRoot != null); Value = aggregateRoot.ToString(); }
public void PersistCreationOf(IAggregateRoot entity) { Book book = _bookMapper.ToDocument((Core.Entities.Book)entity); _books.InsertOne(book); }
public Task AddAsync(IAggregateRoot aggregateRoot) { Add(aggregateRoot); return(Task.CompletedTask); }
public void PersistUpdateOf(IAggregateRoot entity) { }
public void PersistCreationOf(IAggregateRoot entity) { }
public bool ShouldCreateSnapshot(IAggregateRoot snapshotAggregateRoot) { return(true); }
protected void RegisterRollbackUpdate(IAggregateRoot obj) { var args = new RepositoryRollbackEventArgs(obj, this, RepositoryAction.Update); DataContext.Current.RegisterRollback(args); }
public void PersistDeletionOf(IAggregateRoot entity) { }
/// <summary> /// 创建对象 /// </summary> /// <param name="entity"></param> /// <param name="unitofWorkRepository"></param> public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistCreationOf(entity); }
public EntityRepositoryPair(IAggregateRoot entity, IUnitOfWorkRepository repository) { Entity = entity; Repository = repository; }
public void PersistDeletionOf(IAggregateRoot entity) { throw new NotImplementedException(); }
public void PersistUpdateOf(IAggregateRoot entity) { this.Save((TZ)entity); }
public EntityEntry(IAggregateRoot instance, EntityState entityState) { Instance = instance; EntityState = entityState; }
/// <summary> /// 修改对象 /// </summary> /// <param name="entity"></param> /// <param name="unitofWorkRepository"></param> public void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistUpdateOf(entity); }
/// <summary> /// Refuses the specified root. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <param name="root">The root.</param> /// <param name="event">The @event.</param> public void Refuse(IAggregateRoot <TEntity, TId> root, IDomainEvent <TEntity> @event) { //Raul no hace nada es el por defecto, por defecto me la pelo }
public void Track(IAggregateRoot root) { _trackedObjects.Add(root); }
/// <summary> /// 删除对象 /// </summary> /// <param name="entity"></param> /// <param name="unitofWorkRepository"></param> public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistDeletionOf(entity); }
/// <summary> /// Registers an entity to be removed when commited. /// </summary> /// <param name="entity">Entity.</param> /// <param name="repository">Repository.</param> public virtual void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository repository) { Entities.Add(new EntityRepositoryPair(new UnitOfWorkEntity(entity, UnitOfWorkEntityState.Removed), repository)); }
public void PersistUpdate(IAggregateRoot aggregateRoot) { DatabaseType databaseType = RetrieveDatabaseTypeFrom(aggregateRoot); ObjectContextFactory.Create().UpdateEntity <DatabaseType>(databaseType); }