C# IAggregateRoot类代码示例

        public void PersistUpdateOf(IAggregateRoot entity)
        {
            Account account = entity as Account;

            string sql = "UPDATE Account SET [email protected] WHERE [email protected]";
            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 void RegisterUpdate(IAggregateRoot aggregateRoot, IUnitOfWorkRepository repository)
		{
			if (!_updatedAggregates.ContainsKey(aggregateRoot))
			{
				_updatedAggregates.Add(aggregateRoot, repository);
			}
		}

		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 Add(IAggregateRoot entity, IUnitOfWorkRepository uowRepository)
 {
     if (!_addedEntities.ContainsKey(entity))
     {
         _addedEntities.Add(entity, uowRepository);
     }
 }

 public void RegisterAmended(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (!changedEntities.ContainsKey(objectEntity))
     {
         changedEntities.Add(objectEntity, unitOfWorkRepository);
     }
 }

 public void RegisterRemoved(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (!removedEntities.ContainsKey(objectEntity))
     {
         removedEntities.Add(objectEntity, unitOfWorkRepository);
     }
 }

        /// <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 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 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())
     };
 }