public void Subscribe <TIntegrationEvent, TIntegrationEventHandler>()
where TIntegrationEvent : IIntegrationEvent
where TIntegrationEventHandler : IIntegrationEventHandler <TIntegrationEvent>
{
var eventName = _subscriptionManager.GetEventName <TIntegrationEvent>();
var containsKey = _subscriptionManager.HasSubscriptionsForEvent(eventName);
if (containsKey)
{
return;
}
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
using (var channel = _persistentConnection.CreateModel())
{
channel.QueueBind
(
routingKey: eventName,
exchange: _brokerName,
queue: _queueName
);
}
_subscriptionManager.AddSubscription <TIntegrationEvent, TIntegrationEventHandler>();
}
public void Subscribe <T, TH>() where T : IntegrationEvent where TH : IIntegrationEventHandler <T>
{
var eventName = typeof(T).Name.Replace(IntegrationEventSuffix, "");
var containsKey = _subsManager.HasSubscriptionsForEvent <T>();
if (!containsKey)
{
try
{
_subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter {
Label = eventName
},
Name = eventName
}).GetAwaiter().GetResult();
}
catch (ServiceBusException)
{
}
}
_subsManager.AddSubscription <T, TH>();
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subscriptionManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
if (handler == null)
{
continue;
}
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessEvent(Envelope envelope)
{
if (envelope is null)
{
return;
}
if (!_busSubscriptionManager.HasSubscriptionsForEvent(envelope.Key))
{
return;
}
using (var scope = _autofac.BeginLifetimeScope())
{
var subscriptions = _busSubscriptionManager.GetHandlersForEvent(envelope.Key);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler is null)
{
continue;
}
var eventType = _busSubscriptionManager.GetEventTypeByName(envelope.Key);
var integrationEvent = JsonConvert.DeserializeObject(envelope.Data?.ToString(), eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
// ReSharper disable once PossibleNullReferenceException
await(Task) concreteType
.GetMethod(nameof(IIntegrationEventHandler <IIntegrationEvent> .Handle))
?.Invoke(handler, new[] { integrationEvent });
}
}
}
private void DoInternalSubscription(string eventName)
{
var containsKey = _subscriptionManager.HasSubscriptionsForEvent(eventName);
if (containsKey)
{
return;
}
if (!_persister.IsConnected)
{
_persister.TryConnect();
}
using (var channel = _persister.CreateModel())
channel.QueueBind(_queueName, BROKER_NAME, eventName);
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var handlertypes = _subsManager.GetHandlersForEvent(eventName);
foreach (var handlerType in handlertypes)
{
var handler = _services.GetService(handlerType);
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
//bind queue
private void DoInternalSubscription(string eventName)
{
var containsKey = _subsManager.HasSubscriptionsForEvent(eventName);
if (!containsKey)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
using (var channel = _persistentConnection.CreateModel())
{
channel.QueueBind(queue: _queueName,
exchange: BROKER_NAME,
routingKey: eventName);
}
}
}
public async ValueTask ProcessEvent <T>(T @event) where T : IntegrationEvent
{
if (_subsManager.HasSubscriptionsForEvent <T>())
{
using (var scope = _scopeFactory.CreateScope())
{
foreach (var handlerType in _subsManager.GetHandlersForEvent <T>())
{
var handler = (IIntegrationEventHandler <T>)scope.ServiceProvider.GetRequiredService(handlerType);
await handler.HandleAsync(@event, _cts.Token);
}
}
}
}
