コード例 #1
0
        public override void Build()
        {
            var builder           = this as ISettingsBuilder;
            var processorSettings = this as ISubscrptionMiddlewareSettings;
            Func <SubscriptionMiddleware> messageHandlerProcessorFactory = () =>
            {
                var handlerFactory = new DefaultHandlerFactory(processorSettings.HandlerFactory);

                var projectionsMiddleware  = new ProjectionsMiddleware(handlerFactory);
                var middleware             = processorSettings.HandleMiddleware(projectionsMiddleware);
                var subscriptionMiddleware = new SubscriptionMiddleware();
                foreach (var reg in processorSettings.HandlerRegistrations)
                {
                    if (typeof(IProjection).IsAssignableFrom(reg))
                    {
                        subscriptionMiddleware.Subscribe(new HandleSubscriber <IProjection, IEventHandler <IEvent> >(reg, middleware));
                    }
                }
                return(subscriptionMiddleware);
            };

            builder.Container.RegisterSingleton <SubscriptionMiddleware>(() => messageHandlerProcessorFactory(), builder.Name);
        }
コード例 #2
0
        public override void Build()
        {
            var hasher            = new ProjectionHasher();
            var builder           = this as ISettingsBuilder;
            var processorSettings = this as ISubscrptionMiddlewareSettings;
            Func <SubscriptionMiddleware> messageHandlerProcessorFactory = () =>
            {
                var handlerFactory = new DefaultHandlerFactory(processorSettings.HandlerFactory);

                //  May be we want to have separate serializer + transport per type?!?!?
                var transport  = builder.Container.Resolve <ITransport>(builder.Name);
                var serializer = builder.Container.Resolve <ISerializer>(null);
                var publisher  = transport.GetPublisher <ICommand>(serializer);

                var projectionsMiddleware  = new ProjectionsMiddleware(handlerFactory);
                var middleware             = processorSettings.HandleMiddleware(projectionsMiddleware);
                var subscriptionMiddleware = new SubscriptionMiddleware();
                var iProjection            = typeof(IProjection);

                foreach (var handler in processorSettings.HandlerRegistrations)
                {
                    if (iProjection.IsAssignableFrom(handler))
                    {
                        subscriptionMiddleware.Subscribe(new HandlerSubscriber <IProjection, IEventHandler <IEvent> >(handler, middleware));
                        var projManagerId = new ProjectionVersionManagerId(handler.GetContractId());
                        var command       = new RegisterProjection(projManagerId, hasher.CalculateHash(handler).ToString());
                        publisher.Publish(command);
                    }
                }
                var indexSubscriber = builder.Container.Resolve <EventTypeIndexForProjections>();
                subscriptionMiddleware.Subscribe(indexSubscriber);
                return(subscriptionMiddleware);
            };

            builder.Container.RegisterSingleton <SubscriptionMiddleware>(() => messageHandlerProcessorFactory(), builder.Name);
        }