C# IEvent.GetType方法代码示例

        public void Flow(IEvent @event)
        {
            var eventsToFlow = new List<IEvent>();
            foreach (var pipelet in pipelets)
            {
                log.DebugFormat("Flowing {0} to {1}", @event.GetType(), pipelet.GetType());
                var resultingEvents = pipelet.Flow(@event);

                if (resultingEvents.Any(e => e.GetType() != typeof (NoopEvent)))
                {
                    log.InfoFormat("Adding {0} events to the pipeline for later flowing, after flowing {1} to {2}",
                                   resultingEvents.Count(),
                                   @event.GetType(),
                                   pipelet.GetType());

                    eventsToFlow.AddRange(resultingEvents);
                }
            }

            log.DebugFormat("Flowing resulting events to the pipeline. There are {0} events to reflow",
                            eventsToFlow.Count);
            foreach (var eventToFlow in eventsToFlow)
            {
                Flow(eventToFlow);
            }
        }

        public IEnumerable<IEvent> Flow(IEvent @event)
        {
            log.InfoFormat("Received {0}", @event.GetType());
            log.DebugFormat("Flowing {0} to decision maker {1} to move the event forward", @event.GetType(),
                            decisionMaker.GetType());

            return decisionMaker.MakeDecision(@event);
        }

        public Envelope(IEvent message)
        {
            this.Headers = message.Headers;
            this.Body = message.Serialize();
            this.EventType = message.GetType().FullName;

            if (string.IsNullOrEmpty(this.Topic)) { this.Topic = message.GetType().FullName; }
        }

        public IEnumerable<IEvent> Flow(IEvent @event)
        {
            log.InfoFormat("Received {0} in pipelet {1}", @event.GetType(), this.GetType());

            if (!WantsEvent(@event))
            {
                log.InfoFormat("Ignoring event {0} because filter is not satisfied", @event.GetType());

                return ListOfEvents.EmptyList();
            }

            return Accept(@event);
        }

 public bool Equals(IEvent toCompare)
 {
     if (toCompare.GetType().Equals(typeof(Unused)))
         return true;
     else
         return false;
 }

 private void OnEvent(IEvent @event, bool isNew)
 {
     string eventName = "On" + @event.GetType().Name.Replace("Event", "");
     MethodInfo method = GetType().GetMethod(eventName);
     method.Invoke(this, new object[] { @event });
     if (isNew)_uncommitedEvents.Add(@event);
 }

        /// <summary>
        /// Apply the event
        /// </summary>
        /// <param name="event"></param>
        /// <param name="isNew"></param>
        public void ApplyChange(IEvent @event, bool isNew = true)
        {
            var targetType = GetType();
            var methodsToMatch = targetType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            var expectedName = string.Format("On{0}", @event.GetType().Name);

            foreach (var method in methodsToMatch) {

                if (string.Compare(method.Name, expectedName, StringComparison.OrdinalIgnoreCase) != 0)
                    continue;

                var parameters = method.GetParameters();

                if (parameters.Length != 1 || !typeof(IEvent).IsAssignableFrom(parameters[0].ParameterType))
                    continue;

                method.Invoke(this, new[] { @event });

                if (isNew)
                    _changes.Add(@event);

                return;
            }

            throw new Exception(string.Format("Could not find a method named {0} on type {1}", expectedName, GetType().Name));
        }

 public void Publish(IEvent @event)
 {
     Console.WriteLine("========================================");
     Console.WriteLine("Publishing event {0}", @event.GetType());
     Console.WriteLine("Event {0}", @event);
     Console.WriteLine("========================================");
 }

		/*============================================================================*/
		/* Private Functions                                                          */
		/*============================================================================*/

		private void EventHandler(IEvent evt)
		{
			/**
			 * Map(CustomType, typeof(IEvent)). 	Dispatch(new CustomEvent(CustomType)).	Make it inject IEvent
			 * Map(CustomType). 					Dispatch(new Event(CustomType)).		Make it inject IEvent
			 * Map(CustomType). 					Dispatch(new CustomEvent(CustomType)).	Make it inject CustomEvent
			 * 
			 * Map(CustomType).typeof(CustomType)	Dispatch(new Event(CustomType)).		Make it not execute
			 */

			Type evtType = evt.GetType ();
			Type payloadEvtType = null;
			if (evtType == _eventClass || (_eventClass == null))
			{
				payloadEvtType = (evtType == typeof(Event)) ? typeof(IEvent) : evtType;
			}
			else if (_eventClass == typeof(IEvent))
			{
				payloadEvtType = _eventClass;
				payloadEvtType = typeof (IEvent);
			}
			else
				return;

			_executor.ExecuteCommands(_mappings.GetList(), new CommandPayload (new List<object>{ evt }, new List<Type>{ payloadEvtType }));
		}

        protected IEnumerable<IPipelet> RebuildPipeline(IEvent @event)
        {
            log.InfoFormat("Rebuilding pipeline for event {0}", @event.GetType());

            var rebuildPipeline = pipelets.Where(p => p.WantsEvent(@event)).ToList();
            return rebuildPipeline;
        }

        public void Send(IEvent @event)
        {
            var eventType = @event.GetType();
            var eventTypes = new List<Type>{ eventType };

            var baseEventType = eventType.BaseType;

            while (baseEventType != null && typeof(IEvent).IsAssignableFrom(baseEventType))
            {
                eventTypes.Add(baseEventType);
                baseEventType = baseEventType.BaseType;
            }

            foreach (var @interface in eventType.GetInterfaces())
            {
                if (typeof(IEvent).IsAssignableFrom(@interface))
                {
                    eventTypes.Add(@interface);
                }
            }

            foreach (var type in eventTypes)
            {
                var handlers = FindDirectHandlers(type);
                InvokeHandlers(@event, handlers);
            }
        }

        public bool SatisfiedBy(IEvent @event)
        {
            if (@event.GetType() != typeof (NumberOfEventsEvent))
                return false;

            return (@event as NumberOfEventsEvent).Number >= greaterThan && successor.SatisfiedBy(@event);
        }

 public EventDescriptor(IEvent eventData, EventHeader header)
     : this()
 {
     var type = eventData.GetType();
     var name = String.Format("{0},{1}", type.FullName, type.Assembly.GetName().Name);
     EventData = new EventData(name, eventData);
     Header = header;
 }

        public static int Instance { get; private set; } // TODO: Re-evaluate need for static instance counter - it was added for testing IoC only

        public void PublishEvent( IEvent evnt )
        {
            List<IEventListener> listeners;
            if ( Listeners.TryGetValue( evnt.GetType(), out listeners ) )
            {
                listeners.ForEach( a => a.HandleEvent( evnt ) );
            }
        }

        protected override IEnumerable<IEvent> Accept(IEvent @event)
        {
            log.DebugFormat("Publishing {0} to {1} publiser", @event.GetType(), publisher.GetType());

            publisher.Publish(@event);

            return ListOfEvents.EmptyList();
        }