private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
//var handler=scope.ResolveOptional(subscription.HandlerType) as ID
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ResolveOptional(subscription.HandlerType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var Event = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handler").Invoke(handler, new object[] { Event });
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptionInfos = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subInfo in subscriptionInfos)
{
var handler = _serviceProvider.GetService(subInfo.HandlerServiceType);
if (subInfo.IsDynamic)
{
dynamic eventData = JsonObject.Parse(message);
await(handler as IDynamicIntegrationEventHandler).Handle(eventData);
}
else
{
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.DeserializeFromString(message, eventType);
var intHandler = handler as IIntegrationEventHandler;
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(intHandler, new[] { integrationEvent });
}
}
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subscriptionsManager.HasSubscriptions(eventName))
{
using (var scope = _serviceProvider.CreateScope())
{
var subscriptions = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("HandleAsync").Invoke(handler, new object[] { integrationEvent });
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
return(false);
}
return(true);
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
using var scope = _scopeFactory.CreateScope();
Type eventType = _subscriptionsManager.GetEventTypeByName(eventName);
try
{
var integrationEvent = (IntegrationEvent)JsonSerializer.NonGeneric.Deserialize(eventType, message);
var handler = scope.ServiceProvider.GetRequiredService <IIncomingEventHandler>();
await handler.HandleAsync(integrationEvent, eventType, eventName);
}
catch (JsonParsingException e)
{
_logger.LogError(e, "Error while serializing event to type");
}
}
else
{
_logger.LogWarning("No subscription for event {eventName}", eventName);
}
_logger.LogTrace("Finished processing RabbitMQ event: {EventName}", eventName);
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
var processed = false;
if (subscriptionManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = serviceCollection.CreateScope())
{
var subscriptions = subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.ServiceProvider.GetRequiredService(subscription.HandlerType);
if (!(handler is IDynamicEventHandler))
{
Console.WriteLine($"Cannot find EventHandler, type {subscription.HandlerType.Name}");
Console.WriteLine();
}
dynamic eventData = JObject.Parse(message);
await((IDynamicEventHandler)handler).Handle(eventData);
}
else
{
var eventType = subscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ServiceProvider.GetRequiredService(subscription.HandlerType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new[] { integrationEvent });
}
}
}
processed = true;
}
else
{
Console.WriteLine("No subscription for RabbitMQ event: {EventName}", eventName);
Console.WriteLine();
}
return(processed);
}
