Esempio n. 1
0
        protected void ApplyAggregateEvent(AggregateEventBase aggregateEvent)
        {
            Version++;

            // TODO: 是否需要 lock?
            aggregateEvent.SetAggregateIdAndVersion(Id, Version);
            PrivateReflectionDynamicObject.WrapObjectIfNeeded(this).Apply(aggregateEvent);
            _aggregateEvents.Add(aggregateEvent);
        }
Esempio n. 2
0
        /// <summary>
        /// save events to db then apply event to state
        /// snapshot will be created for every 10 events
        /// Returns id of the newly applied event(from db)
        /// </summary>
        public async Task <long> ApplyEvents(TEvent[] events, long?rootEventId = null, long?parentEventId = null)
        {
            var aggregateEvents = new AggregateEventBase[events.Length];

            for (int i = 0; i < events.Length; i++)
            {
                // get event type
                var type = events[i].GetType();
                // get event type name and version
                var eventIdentity = EventTypeHelper.GetEventIdentity(type);
                // serialize event for db
                var serialized = JsonSerializer.Serialize(events[i], type);
                // increment aggregate version
                _aggregateVersion++;
                // add aggregateeventbase
                aggregateEvents[i] = new AggregateEventBase
                {
                    AggregateId      = AggregateId,
                    AggregateVersion = _aggregateVersion,
                    Type             = eventIdentity.Name,
                    EventVersion     = eventIdentity.Version,
                    Data             = serialized,
                    RootEventId      = rootEventId,
                    ParentEventId    = parentEventId,
                    Created          = DateTime.UtcNow
                };
            }
            var eventId = await _repository.SaveEvents(
                _aggregateName,
                aggregateEvents
                );

            for (int i = 0; i < events.Length; i++)
            {
                // update state
                _aggregate.Apply(events[i]);

                // save snapshot if ShouldSaveSnapshot returns true
                if (_shouldSaveSnapshot(events[i], _aggregateVersion))
                {
                    await SaveSnapshot();
                }
            }

            // return id
            return(eventId);
        }
Esempio n. 3
0
        public async Task Test1()
        {
            // arrange
            var postgresRepo = new PostgresRepository("host=localhost;database=EventSourcing;username=orleans;password=5544338;Enlist=false;Maximum Pool Size=90;");
            var events       = new AggregateEventBase[]
            {
                new AggregateEventBase {
                    AggregateId = 3, AggregateVersion = 6744, EventVersion = 0, ParentEventId = null, RootEventId = null, Type = "TransferDebited", Data = "", Created = DateTime.UtcNow
                },
                new AggregateEventBase {
                    AggregateId = 3, AggregateVersion = 6745, EventVersion = 0, ParentEventId = null, RootEventId = null, Type = "TransferDebited", Data = "", Created = DateTime.UtcNow
                },
            };

            // act
            var id = await postgresRepo.SaveEvents("account", events);

            // assert
            Assert.NotEqual(0, id);
        }
        // deserialize from db event
        public static object DeserializeEvent(AggregateEventBase dbEvent)
        {
            var eventType = EventTypeHelper.GetEventType((dbEvent.Type, dbEvent.EventVersion));

            return(JsonSerializer.Deserialize(dbEvent.Data, eventType));
        }