private void RegistrarUnicoBoundedContext(SimpleInventarioDbContext context, IEventHandlerRegistry rebuildEventProcessor, ITracer tracer) { var readModelGeneratorEngine = new ReadModelGeneratorEngine <SimpleInventarioDbContext>(context, tracer); var readModelGenerator = new SimpleInventarioReadModelGenerator(readModelGeneratorEngine); rebuildEventProcessor.Register(readModelGenerator); }
private void RegisterAditionalEventHandlers(IUnityContainer container, IEventHandlerRegistry eventProcessor) { // Register aditional Event Handlers here that does not belong to a Domain Bounded Context // Example: Logger //eventProcessor.Register(container.Resolve<MessageLogHandler>()); }
protected StateBase() { IsFrozen = false; EventHandlerMethod[] methods = MethodConvetion.ResolveEventMethods(GetType()).ToArray(); registry = new EventHandlerRegistry(); registry.Add(methods); }
public EventDispatcher(IEventHandlerRegistry registry) { if (registry == null) { throw new ArgumentNullException(nameof(registry)); } _registry = registry; }
public DefaultEventBusServiceBusMessageProcessor(IEventHandlerRegistry eventHandlerRegistry, IServiceProvider serviceProvider, ILogger logger, IEventBusMessagePublisher messagePublisher) { this._eventHandlerRegistry = eventHandlerRegistry; this._logger = logger; this._serviceProvider = serviceProvider; this._messagePublisher = messagePublisher; }
public static void HandleEvent <TMessage>(this IEventHandlerRegistry registry, Action <TMessage> onEvent) { registry.RegisterEvent <TMessage>(x => { onEvent(x); return(Task.CompletedTask); }); }
public DefaultEventDispatcher(IEventHandlerRegistry handlerRegistry, IHandlerInvoker handlerInvoker) { Check.Argument.IsNotNull(handlerRegistry, "handlerRegistry"); Check.Argument.IsNotNull(handlerInvoker, "handlerInvoker"); _handlerRegistry = handlerRegistry; _handlerInvoker = handlerInvoker; }
public static void SimpleInventarioRegistrarUnicoBoundedContext (IUnityContainer container, IEventHandlerRegistry eventProcessor) { // Commanding container.RegisterType <ICommandHandler, InventarioHandler>("InventarioHandler"); // Reporting eventProcessor.Register(container.Resolve <AnimalesDeTodosLosPeriodosHandler>()); }
public AggregateRootServices(IEventFactory eventFactory, IEventHandlerRegistry eventHandlerRegistry, int errorOnStreamLength) { Expect.NotNull(eventFactory, nameof(eventFactory)); Expect.NotNull(eventHandlerRegistry, nameof(eventHandlerRegistry)); Expect.Range(errorOnStreamLength, 0, int.MaxValue, nameof(errorOnStreamLength)); EventFactory = eventFactory; EventHandlerRegistry = eventHandlerRegistry; ErrorOnStreamLength = errorOnStreamLength; }
public void Load(IEventHandlerRegistry registry) { /* EventTypeMissingEventAttribute(Tests.SkipEvent) */ registry.RegisterEventHandler <SkipEvent, AttributedSkipEventHandler>() /**/; /* EventTypeMissingEventAttribute(Tests.SkipEvent) */ registry.RegisterOrgEventHandler <SkipEvent, AttributedSkipOrgEventHandler>() /**/; } } public sealed class WithoutEventHandlerAttribute { public void Load(IEventHandlerRegistry registry) { /* EventHandlerTypeMissingEventAttribute(Tests.NonAttributedJumpEventHandler) */ registry.RegisterEventHandler <JumpEvent, NonAttributedJumpEventHandler>() /**/; /* EventHandlerTypeMissingEventAttribute(Tests.NonAttributedJumpOrgEventHandler) */ registry.RegisterOrgEventHandler <JumpEvent, NonAttributedJumpOrgEventHandler>() /**/; }
/// <summary> /// Initializes a new instance of the <see cref="IocEventBus" /> class. /// </summary> /// <param name="container">Used to resolve <c><![CDATA[IApplicationEventSubscriber<TApplicationEvent>]]></c>.</param> /// <param name="registry"> /// Used to be able to identify all concrete events handler to be able to resolve them in seperate scopes. This also /// means that each /// handler have to be registered as itself in the container. /// </param> /// <exception cref="System.ArgumentNullException">container</exception> public SeparateScopesIocEventBus(IContainer container, IEventHandlerRegistry registry) { if (container == null) { throw new ArgumentNullException("container"); } if (registry == null) { throw new ArgumentNullException(nameof(registry)); } _container = container; _registry = registry; }
public InternalEventProcessor( AsyncConcurrentQueue <IEvent> queue, IServiceProvider provider, IEventHandlerRegistry dispatchers, ILogger <InternalEventProcessor> logger, IExceptionHandlerRegistry?exceptionHandlerRegistry = null) { _queue = queue; _dispatchers = dispatchers; _provider = provider; _logger = logger; _exceptionHandlerRegistry = exceptionHandlerRegistry; }
/// <summary> /// Un ejemplo de cómo registrar bounded contexts /// </summary> private void RegistrarUnicoBoundedContext(IUnityContainer container, IEventHandlerRegistry liveEventProcessor) { // ReadModeling Func <SimpleInventarioDbContext> contextFactory = () => new SimpleInventarioDbContext(this.Config.ReadModelConnectionString); container.RegisterType <IReadModelGeneratorEngine <SimpleInventarioDbContext>, ReadModelGeneratorEngine <SimpleInventarioDbContext> >( new ContainerControlledLifetimeManager(), new InjectionConstructor( contextFactory, container.Resolve <ITracer>())); liveEventProcessor.Register(container.Resolve <SimpleInventarioReadModelGenerator>()); }
public override void Context() { var subscribeMethodInfo = typeof(SampleClassWithEvent).GetEvent(SampleEventName).GetAddMethod(); Call = CreateCall(subscribeMethodInfo, new object[0]); EventArguments = new[] { new object(), EventArgs.Empty }; _getEventArguments = mock <Func <ICall, object[]> >(); _getEventArguments.stub(x => x(Call)).Return(EventArguments); EventHandler = mock <EventHandler <EventArgs> >(); _handlers = new object[] { EventHandler }; _eventHandlerRegistry = mock <IEventHandlerRegistry>(); _eventHandlerRegistry.Stub(x => x.GetHandlers(SampleEventName)).Return(_handlers); }
//init public EventProcessor(SenderState <TKey> hubState, IMonitor <TKey> eventSink , ILogger logger, SenderSettings senderSettings , IEventQueue <TKey> eventQueue, IDispatchQueue <TKey> dispatchQueue , IEventHandlerRegistry <TKey> handlerRegistry, IEventSettingsQueries <TKey> eventSettingsQueries) : base(logger) { _hubState = hubState; _monitor = eventSink; _eventQueue = eventQueue; _dispatchQueue = dispatchQueue; _handlerRegistry = handlerRegistry; _eventSettingsQueries = eventSettingsQueries; MaxParallelItems = senderSettings.MaxParallelEventsProcessed; }
public MassTransit(ICommandHandlerRegistry commandRegistry, IEventHandlerRegistry eventRegistry, Container container) { _container = container; _serviceBus = ServiceBusFactory.New(sbc => { sbc.UseRabbitMq(); sbc.ReceiveFrom("rabbitmq://192.168.10.201/mybus"); sbc.Subscribe(x => { eventRegistry.GetEvents((commandType) => { RegisterHandler(x, commandType); }); }); }); }
public static void Register <TEvent>(this IEventHandlerRegistry registry, IEventHandler <TEvent> handler) { if (registry == null) { throw new ArgumentNullException("registry"); } if (handler == null) { throw new ArgumentNullException("handler"); } var eventDataType = typeof(TEvent); Action <IPublishableEvent> action = ev => handler.Handle((IPublishedEvent <TEvent>)ev); registry.Register(eventDataType, action); }
public EventBusServiceBus(AzureServiceBusSettings azureServiceBusSettings, IEventHandlerRegistry eventHandlerRegistry, IServiceProvider serviceProvider, ILogger logger) { this._azureServiceBusSettings = azureServiceBusSettings; this._eventHandlerRegistry = eventHandlerRegistry; this._serviceProvider = serviceProvider; this._logger = logger; this._topicClient = new TopicClient(_azureServiceBusSettings.ServiceBusConnectionString, _azureServiceBusSettings.TopicName); // CMS Api only sends messages. So Subscription would be empty if (!string.IsNullOrEmpty(_azureServiceBusSettings.SubscriptionName)) { this._subscriptionClient = new SubscriptionClient(_azureServiceBusSettings.ServiceBusConnectionString, _azureServiceBusSettings.TopicName, _azureServiceBusSettings.SubscriptionName); } }
public EventDispatcher(IEventHandlerRegistry registry) { if (registry == null) throw new ArgumentNullException(nameof(registry)); _registry = registry; }
public EventSubscriptionHandler(IEventHandlerRegistry eventHandlerRegistry) { _eventHandlerRegistry = eventHandlerRegistry; }
public EventProcessor(IEventHandlerRegistry eventHandlerRegistry) { _registry = eventHandlerRegistry; }
public BusLifetime(Container container, IBus bus, ICommandBus commandBus, IEventBus eventBus, ICommandHandlerRegistry commandHandlerRegistry, IEventHandlerRegistry eventHandlerRegistry) { _container = container; _bus = bus; _commandBus = commandBus; _eventBus = eventBus; commandHandlerRegistry.GetCommands(type => { var genericArguements = type.GetGenericArguments(); if (genericArguements.Count() == 1) { RegisterCommandHandler(genericArguements[0]); } else { RegisterCommandResponseHandler(genericArguements[0], genericArguements[1]); } }); eventHandlerRegistry.GetEvents(RegisterEventHandler); }
public RaiseEventHandler(IEventHandlerRegistry eventHandlerRegistry, Func<ICall, object[]> getEventArguments) { _eventHandlerRegistry = eventHandlerRegistry; _getEventArguments = getEventArguments; }
public DefaultEventDispatcher(IEventHandlerRegistry handlerRegistry) : this(handlerRegistry, new DefaultHandlerInvoker()) { }
public override void Context() { _eventHandlerRegistry = mock <IEventHandlerRegistry>(); }
static Helper() { AllEventTypesFromDomain = Util.FindEventTypes(".Events", new[] { typeof(CustomerAggregate).Assembly }); EventFactory = new EventFactory(AllEventTypesFromDomain); EventHandlerRegistry = new EventHandlerRegistry(); }
public void Init() { _mockRegistry = Substitute.For <IEventHandlerRegistry>(); _mockHandler = Substitute.For <IEventHandler <TestEventData> >(); _processor = new EventProcessor(_mockRegistry); }
public RaiseEventHandler(IEventHandlerRegistry eventHandlerRegistry, Func <ICall, object[]> getEventArguments) { _eventHandlerRegistry = eventHandlerRegistry; _getEventArguments = getEventArguments; }
public void Load(IEventHandlerRegistry registry) { registry.RegisterEventHandler <JumpEvent, AttributedJumpEventHandler>(); registry.RegisterOrgEventHandler <JumpEvent, AttributedJumpOrgEventHandler>(); }