C# IAggregateRoot.GetType方法代码示例

		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 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 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;
        }

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

        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>
 /// 将一个FisObject注册为Added
 ///</summary>
 ///<param name="entity">fisobject</param>
 ///<param name="repository">该FisObject类型的Repository对象</param>
 public void RegisterAdded(IAggregateRoot entity, IUnitOfWorkRepository repository)
 {
     if (!this._added.ContainsKey(entity))
     {
         logger.DebugFormat(MsgRegisterAdded, entity.GetType(), entity.Key);
         this._added.Add(entity, repository);
         _execSeq.Add(entity);
     }
 }

 public ConcurrencyException(IAggregateRoot aggregate)
     : base(string.Format("Two different versions of aggregate root {0} of type '{1}' was detected in one DataSession",
                 ((IEntity) aggregate).IdObject, aggregate.GetType().Name))
 {
     Aggregate = aggregate;
 }

		public ConcurrencyException(IAggregateRoot root, IDomainEvent conflictEvent)
			: base(string.Format("Expected version of {0}({1}) to be {2} but got {3}."
			, root.GetType().Name, root.Id, root.Version, conflictEvent.Version))
		{
		}

        private EventStream CreateEventStream(IAggregateRoot aggregateRoot, ICommand command)
        {
            var uncommittedEvents = aggregateRoot.GetUncommittedEvents().ToList();
            aggregateRoot.ClearUncommittedEvents();

            var aggregateRootTypeCode = _aggregateRootTypeProvider.GetTypeCode(aggregateRoot.GetType());

            foreach (var evnt in uncommittedEvents)
            {
                evnt.Version = aggregateRoot.Version + 1;
            }
            return new EventStream(
                command.Id,
                aggregateRoot.UniqueId,
                aggregateRootTypeCode,
                aggregateRoot.Version + 1,
                DateTime.Now,
                uncommittedEvents);
        }

        private void PublishEvents(IAggregateRoot instance, IDomainNotification snapshotChange)
        {
            foreach (var evt in instance.UncommittedEvents.ToList())
            {
                var modelChange = NotificationExtensions.CreateNotification(instance.GetType(), evt);
                this.changes.OnNext(modelChange);
            }

            if (snapshotChange != null)
            {
                this.changes.OnNext(snapshotChange);
            }
        }

        private void HandleEvent(IAggregateRoot aggregateRoot, IDomainEvent evnt)
        {
            var handler = _eventHandlerProvider.GetInternalEventHandler(aggregateRoot.GetType(), evnt.GetType());
            if (handler == null)
            {
                throw new ENodeException("Could not find event handler for [{0}] of [{1}]", evnt.GetType().FullName, aggregateRoot.GetType().FullName);
            }

            handler(aggregateRoot, evnt);
        }

 private void IncreaseAggregateVersion(IAggregateRoot aggregateRoot)
 {
     _increaseVersionMethodDict[aggregateRoot.GetType()](aggregateRoot);
 }