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 EventSubscriptionHandler(IEventHandlerRegistry eventHandlerRegistry)
{
_eventHandlerRegistry = eventHandlerRegistry;
}
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>();
}
