コード例 #1
0
        protected override Task WriteEventsToStoreAsync(IEnumerable <IDomainEventDescriptor> events, CancellationToken cancellationToken)
        {
            foreach (var @event in events)
            {
                var streams    = _store.GetOrAdd(@event.AggregateType, new ConcurrentDictionary <string, List <IDomainEventDescriptor> >());
                var eventsList = streams.GetOrAdd(@event.AggregateId, new List <IDomainEventDescriptor>());

                var publishedEvent = DomainEventDescriptor.FromStore(@event.AggregateType, @event.AggregateId, @event.Event, @event.Version, @event.EventType);

                eventsList.Add(publishedEvent);
            }

            return(Task.CompletedTask);
        }
コード例 #2
0
        public override async IAsyncEnumerable <IDomainEventDescriptor> GetAggregateEvents <TKey>(string aggregateType, TKey id, long afterVersion, [EnumeratorCancellation] CancellationToken cancellationToken)
        {
            var streamName = GenerateStreamId(aggregateType, id);

            ReadStreamResult eventStoreDbEvents;

            if (afterVersion == -1)
            {
                eventStoreDbEvents = EventStoreClient.ReadStreamAsync(
                    Direction.Forwards,
                    streamName,
                    StreamPosition.Start,
                    cancellationToken: cancellationToken);
            }
            else
            {
                eventStoreDbEvents = EventStoreClient.ReadStreamAsync(
                    Direction.Forwards,
                    streamName,
                    StreamPosition.FromInt64(afterVersion + 1),
                    cancellationToken: cancellationToken);
            }

            if (await eventStoreDbEvents.ReadState == ReadState.StreamNotFound)
            {
                yield break;
            }

            var eventDescriptors = eventStoreDbEvents.Select(@event =>
            {
                var version      = @event.Event.EventNumber.ToInt64();
                var bsonData     = @event.Event.Data;
                var bsonMetadata = @event.Event.Metadata;
                var eventType    = @event.Event.EventType;

                DomainEventDescriptor descriptor;

                using (var stream = bsonData.AsStream())
                    using (var reader = new BsonDataReader(stream))
                    {
                        JsonSerializer serializer   = new JsonSerializer();
                        serializer.TypeNameHandling = TypeNameHandling.All;
                        var domainEvent             = serializer.Deserialize <IDomainEvent>(reader);
                        descriptor = DomainEventDescriptor.FromStore(aggregateType, id.ToString(), domainEvent, version, eventType);
                    }

                using (var stream = bsonMetadata.AsStream())
                    using (var reader = new BsonDataReader(stream))
                    {
                        JsonSerializer serializer   = new JsonSerializer();
                        serializer.TypeNameHandling = TypeNameHandling.All;
                        var metadata = serializer.Deserialize <IDictionary <string, string> >(reader);

                        foreach (var keyValue in metadata)
                        {
                            descriptor.Metadata.Add(keyValue.Key, keyValue.Value);
                        }
                    }

                return(descriptor);
            });

            await foreach (var eventDescriptor in eventDescriptors)
            {
                yield return(eventDescriptor);
            }
        }