示例#1
0
        private void DiscoverWhens(AggregateSchema type)
        {
            foreach (var whenMethod in GetWhensMethods(type.Type))
            {
                var cmdType  = whenMethod.GetParameters()[1].ParameterType;
                var category = ServiceConventions.GetCategoryFromNamespace(cmdType.Namespace);
                if (category != type.Category)
                {
                    throw new CategoryMismatchByNamespaceException(cmdType, type.Type);
                }

                Type[] events = Array.Empty <Type>();
                if (typeof(IEvent).IsAssignableFrom(whenMethod.ReturnType) && whenMethod.ReturnType.IsClass)
                {
                    events = new Type[] { whenMethod.ReturnType }
                }
                ;
                else
                {
                    var attribute = whenMethod.GetCustomAttribute <EmittingEventsAttribute>();
                    if (attribute != null)
                    {
                        events = attribute.EventTypes;
                    }
                }
                var commandSchema = new CommandSchema(cmdType, category, cmdType.IsPublic, false, null, events);
                _commands.Add(commandSchema);
                type.Commands.Add(commandSchema);
                _commandIndex.TryAdd(cmdType, type);
            }
        }
示例#2
0
        public void Discover(IEnumerable <Type> types)
        {
            var aggregateTypes = types
                                 .Where(t => typeof(IAggregate).IsAssignableFrom(t) && !t.IsAbstract)
                                 .ToArray();

            foreach (var type in aggregateTypes)
            {
                var metadata = new AggregateSchema(type);
                _aggregates.Add(type, metadata);
                DiscoverWhens(metadata);
                DiscoverGivens(metadata);
            }

            var events = types.Where(x => typeof(IEvent).IsAssignableFrom(x) && !x.IsAbstract)
                         .ToArray();

            foreach (var eventType in events)
            {
                if (!_eventIndex.ContainsKey(eventType))
                {
                    string category  = ServiceConventions.GetCategoryFromNamespace(eventType.Namespace);
                    var    aggregate = _aggregates.Values.FirstOrDefault(x => x.Category == category);
                    if (aggregate != null)
                    {
                        var isOwnedByAggregate  = aggregate.Type.Namespace == eventType.Namespace;
                        AggregateEventSchema es = new AggregateEventSchema(eventType, false, isOwnedByAggregate);
                        aggregate.Events.Add(es);
                    }
                }
            }

            var commands = types.Where(x => typeof(ICommand).IsAssignableFrom(x) && !x.IsAbstract).ToArray();

            foreach (var command in commands.Where(x => !_commandIndex.ContainsKey(x)))
            {
                var customHandler = typeof(ICommandHandler <>).MakeGenericType(command);
                var handler       = types.FirstOrDefault(x => customHandler.IsAssignableFrom(x));
                if (handler != null)
                {
                    _commands.Add(new CommandSchema(command,
                                                    ServiceConventions.GetCategoryFromNamespace(command.Namespace),
                                                    command.IsPublic, true, handler));
                }
                else
                {
                    Debug.WriteLine($"Found a dangling command: {command.FullName}");
                }
            }
        }
示例#3
0
        private void DiscoverGivens(AggregateSchema type)
        {
            foreach (var givenMethod in GetGivensMethods(type.Type))
            {
                var eventType = givenMethod.GetParameters()[1].ParameterType;
                if (givenMethod.ReturnType != type.StateType)
                {
                    throw new InvalidAggregateSchemaException(type.Type, eventType);
                }

                var isOwnedByAggregate = eventType.Namespace == type.Type.Namespace;

                AggregateEventSchema es = new AggregateEventSchema(eventType, true, isOwnedByAggregate);
                type.Events.Add(es);
                _events.Add(es);
                _eventIndex.TryAdd(eventType, type);
            }
        }