public void set_version_single_stream_on_internal(Type aggregateType, AggregationScope scope, long expected)
    {
        var e = new Event <EventA>(new EventA())
        {
            Sequence = SequenceVersion, Version = StreamVersion
        };

        var versioning =
            typeof(AggregateVersioning <>).CloseAndBuildAs <IAggregateVersioning>(
                scope, aggregateType);
        var aggregate = Activator.CreateInstance(aggregateType);

        versioning.TrySetVersion(aggregate, e);
    }
        protected GeneratedAggregateProjectionBase(AggregationScope scope) : base(typeof(T).NameInCode())
        {
            _createMethods       = new CreateMethodCollection(GetType(), typeof(T));
            _applyMethods        = new ApplyMethodCollection(GetType(), typeof(T));
            _shouldDeleteMethods = new ShouldDeleteMethodCollection(GetType(), typeof(T));

            Options.DeleteViewTypeOnTeardown <T>();

            _allEventTypes = new Lazy <Type[]>(() =>
            {
                return(_createMethods.Methods.Concat(_applyMethods.Methods).Concat(_shouldDeleteMethods.Methods)
                       .Select(x => x.EventType).Concat(DeleteEvents).Concat(TransformedEvents).Distinct().ToArray());
            });


            _inlineAggregationHandlerType = GetType().ToSuffixedTypeName("InlineHandler");
            _liveAggregationTypeName      = GetType().ToSuffixedTypeName("LiveAggregation");
            _versioning = new AggregateVersioning <T>(scope);
        }
Пример #3
0
        public AggregateVersioning(AggregationScope scope)
        {
            _setValue = new(buildAction);
            _scope    = scope;

            var bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

            var props = typeof(T).GetProperties(bindingFlags)
                        .Where(x => x.CanWrite)
                        .Where(x => x.PropertyType == typeof(int) || x.PropertyType == typeof(long))
                        .OfType <MemberInfo>();

            var fields = typeof(T).GetFields(bindingFlags)
                         .Where(x => x.FieldType == typeof(int) || x.FieldType == typeof(long))
                         .OfType <MemberInfo>();

            var members = props.Concat(fields);

            // ReSharper disable once PossibleMultipleEnumeration
            VersionMember = members.FirstOrDefault(x => x.HasAttribute <VersionAttribute>());
            // ReSharper disable once PossibleMultipleEnumeration
            VersionMember ??= members.FirstOrDefault(x =>
                                                     x.Name.EqualsIgnoreCase("version") && !x.HasAttribute <MartenIgnoreAttribute>());
        }