C# IEventSource.GetType方法代码示例

 public NcqrsEventSource(IEventSource source)
     : base("Source_" + source.EventSourceId.ToString(),
         "Source_" + source.EventSourceId.ToString())
 {
     Timestamp = DateTime.UtcNow;
     Version = source.Version;
     Name = source.GetType().ToString();
 }

        public static EventSourceEntity CreateFromEventSource(IEventSource source)
        {
            Contract.Requires<ArgumentNullException>(source != null, "The source cannot be null.");

            return new EventSourceEntity
            {
                RowKey = source.EventSourceId.ToString(),
                PartitionKey = source.GetType().FullName,
                Version = source.Version
            };
        }

        public IEnumerable<ISourcedEventHandler> GetEventHandlersFromAggregateRoot(IEventSource eventSource)
        {
            Contract.Requires<ArgumentNullException>(eventSource != null, "The eventSource cannot be null.");
            Contract.Ensures(Contract.Result<IEnumerable<ISourcedEventHandler>>() != null, "The result should never be null.");

            var targetType = eventSource.GetType();
            var handlers = new List<ISourcedEventHandler>();

            Logger.DebugFormat("Trying to get all event handlers based by convention for {0}.", targetType);

            var methodsToMatch = targetType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            var matchedMethods = from method in methodsToMatch
                                 let parameters = method.GetParameters()
                                 let noEventHandlerAttributes =
                                     method.GetCustomAttributes(typeof(NoEventHandlerAttribute), true)
                                 where
                                     // Get only methods where the name matches.
                                    Regex.IsMatch(method.Name, _regexPattern, RegexOptions.CultureInvariant) &&
                                     // Get only methods that have 1 parameter.
                                    parameters.Length == 1 &&
                                     // Get only methods where the first parameter is an event.
                                    typeof(IEvent).IsAssignableFrom(parameters[0].ParameterType) &&
                                     // Get only methods that are not marked with the no event handler attribute.
                                    noEventHandlerAttributes.Length == 0
                                 select
                                    new { MethodInfo = method, FirstParameter = method.GetParameters()[0] };

            foreach (var method in matchedMethods)
            {
                var methodCopy = method.MethodInfo;
                Type firstParameterType = methodCopy.GetParameters().First().ParameterType;

                Action<IEvent> invokeAction = (e) => methodCopy.Invoke(eventSource, new object[] { e });

                Logger.DebugFormat("Created event handler for method {0} based on convention.", methodCopy.Name);

                var handler = new TypeThresholdedActionBasedDomainEventHandler(invokeAction, firstParameterType, true);
                handlers.Add(handler);
            }

            return handlers;
        }

        /// <summary>
        /// Gets the event handlers from aggregate root based on attributes.
        /// </summary>
        /// <param name="eventSource">The aggregate root.</param>
        /// <see cref="AttributeBasedDomainSourcedEventHandlerMappingStrategy"/>
        /// <returns>All the <see cref="IDomainEventHandler"/>'s created based on attribute mapping.</returns>
        public IEnumerable<ISourcedEventHandler> GetEventHandlersFromAggregateRoot(IEventSource eventSource)
        {
            Contract.Requires<ArgumentNullException>(eventSource != null, "The eventSource cannot be null.");

            var targetType = eventSource.GetType();
            var handlers = new List<ISourcedEventHandler>();

            foreach (var method in targetType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static))
            {
                EventHandlerAttribute attribute;

                if (IsMarkedAsEventHandler(method, out attribute))
                {
                    if (method.IsStatic) // Handlers are never static. Since they need to update the internal state of an eventsource.
                    {
                        var message = String.Format("The method {0}.{1} could not be mapped as an event handler, since it is static.", method.DeclaringType.Name, method.Name);
                        throw new InvalidEventHandlerMappingException(message);
                    }
                    if (NumberOfParameters(method) != 1) // The method should only have one parameter.
                    {
                        var message = String.Format("The method {0}.{1} could not be mapped as an event handler, since it has {2} parameters where 1 is required.", method.DeclaringType.Name, method.Name, NumberOfParameters(method));
                        throw new InvalidEventHandlerMappingException(message);
                    }
                    if (!typeof(IEvent).IsAssignableFrom(FirstParameterType(method))) // The parameter should be an IEvent.
                    {
                        var message = String.Format("The method {0}.{1} could not be mapped as an event handler, since it the first parameter is not an event type.", method.DeclaringType.Name, method.Name);
                        throw new InvalidEventHandlerMappingException(message);
                    }

                    var handler = CreateHandlerForMethod(eventSource, method, attribute);
                    handlers.Add(handler);
                }
            }

            return handlers;
        }

 /// <summary>
 /// Adds the event source to the event store.
 /// </summary>
 /// <param name="eventSource">The event source to add.</param>
 /// <param name="transaction">The transaction.</param>
 private static void AddEventSource(IEventSource eventSource, SqlTransaction transaction)
 {
     using (var command = new SqlCommand(InsertNewProviderQuery, transaction.Connection))
     {
         command.Transaction = transaction;
         command.Parameters.AddWithValue("Id", eventSource.Id);
         command.Parameters.AddWithValue("Type", eventSource.GetType().ToString());
         command.Parameters.AddWithValue("Version", eventSource.Version);
         command.ExecuteNonQuery();
     }
 }

 private void AddEventSource(IEventSource eventSource, SQLiteTransaction transaction)
 {
     using (var cmd = new SQLiteCommand(Query.InsertNewProviderQuery, transaction.Connection))
     {
         cmd.SetTransaction(transaction)
             .AddParam("Id", eventSource.EventSourceId)
             .AddParam("Type", eventSource.GetType().ToString())
             .AddParam("Version", eventSource.Version);
         cmd.ExecuteNonQuery();
     }
 }