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 IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ResolveOptional(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task HandleReceivedMessage(IReceiverClient receiverClient, ISenderClient senderClient,
Message message, CancellationToken token)
{
var eventName = message.Label;
var messageData = Encoding.UTF8.GetString(message.Body);
await ProcessEvent(eventName, messageData);
// Complete the message so that it is not received again.
await receiverClient.CompleteAsync(message.SystemProperties.LockToken);
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
if (eventType != null && eventType != typeof(CompletedEvent))
{
var eventData = JObject.Parse(messageData);
if (Guid.TryParse((string)eventData["Id"], out var eventId))
{
var publisherId = (string)eventData["PublisherId"];
var completedEvent = new CompletedEvent(eventId, publisherId);
await PublishEventAsync(completedEvent, senderClient);
}
}
}
private EventHandler <MsgHandlerEventArgs> Consumer_Received()
{
return(async(sender, args) =>
{
var eventName = args.Message.Subject;
var message = Encoding.UTF8.GetString(args.Message.Data);
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.Deserialize(message, eventType) as IntegrationEvent;
ISpanContext spanCtx = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(integrationEvent.TracingKeys));
using var tracingScope = _tracer.BuildSpan($"EventBus-Consume-{eventName}")
.AsChildOf(spanCtx)
.WithTag(Tags.SpanKind, Tags.SpanKindConsumer)
.StartActive(finishSpanOnDispose: true);
try
{
await ProcessEvent(eventName, message);
}
catch (Exception ex)
{
tracingScope.Span.SetTag(Tags.Error, true);
tracingScope.Span.Log(ex.Message);
_logger.LogWarning(ex, "----- ERROR Processing message \"{Message}\"", message);
}
});
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = subscription.HandlerType as IDynamicIntegrationEventHandler;
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
dynamic eventData = JsonSerializer.Deserialize(message, eventType);
await Task.Yield();
await handler.Handle(eventData);
}
else
{
var handler = subscription.HandlerType;
if (handler == null)
{
continue;
}
var handlerConstructor = handler.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
.OrderByDescending(c => c.GetParameters().Length).First();
var parameters = handlerConstructor.GetParameters();
var arguments = parameters.Select(p => _serviceProvider.GetService(p.ParameterType)).ToArray();
dynamic objectHandler = handlerConstructor.Invoke(arguments);
var eventType = _subsManager.GetEventTypeByName(eventName);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
dynamic integrationEvent = JsonSerializer.Deserialize(message, eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(objectHandler, new object[] { integrationEvent });
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}.", eventName);
}
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_eventBusSubscriptionsManager.HasSubscriptionsForEvent(eventName))
{
if (_lifetimeScope != null)
{
using (var scope = _lifetimeScope.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _eventBusSubscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _eventBusSubscriptionsManager.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 });
}
}
}
else
{
using (var scope = _serviceScope.CreateScope())
{
var subscriptions = _eventBusSubscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _eventBusSubscriptionsManager.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 });
}
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
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 integrationEvent = JsonSerializer.Deserialize(message, eventType,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
var processed = false;
if (_subscriptionManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = _serviceProvider.GetRequiredService(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("HandleAsync").Invoke(handler, new object[] { integrationEvent });
processed = true;
}
}
return(processed);
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = _service.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = message.ToType(eventType); // JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
/// <param name="eventName"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (IServiceScope scope = _serviceProvider.CreateScope())
{
IServiceProvider services = scope.ServiceProvider;
IEnumerable <SubscriptionInfo> subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (SubscriptionInfo subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = services.GetRequiredService(subscription.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
Type eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = services.GetRequiredService(subscription.HandlerType);
Type concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
var isHandled = false;
var eventName = message.MessageId;
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
if (subscriptions == null || !subscriptions.Any())
{
return;
}
foreach (var subscription in subscriptions)
{
var eventType = subscription.HandlerType;
var messageType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = message.Body;
var handler = _handler.FirstOrDefault(c => c.GetType() == eventType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(messageType);
var methodTask = concreteType.GetMethod("HandleAsync");
if (methodTask == null)
{
continue;
}
isHandled = await InvokeMethodAsync(integrationEvent, handler, methodTask).ConfigureAwait(false);
}
if (isHandled)
{
await queueClient.CompleteAsync(message.SystemProperties.LockToken);
}
}
private async Task<bool> ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);
await (Task)concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
return true;
}
}
return false;
}
private async Task ProcessEvent(string eventName, string message)
{
Logger.LogTrace("Processando evento do RabbitMQ: {EventName}", eventName);
if (!SubscriptionManager.HasSubscriptionsForEvent(eventName))
{
Logger.LogWarning("Não existem consumidores para o evendo do RabbitMQ: {EventName}", eventName);
return;
}
var subscriptions = SubscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = ServiceProvider.GetService(subscription.HandlerType);
var method = subscription.HandlerType.GetMethod("Handle");
var eventType = SubscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = (IntegrationEvent)JsonConvert.DeserializeObject(message, eventType);
//Forcing asynchronous call
await Task.Yield();
await(Task) method.Invoke(handler, new object[] { integrationEvent });
}
}
/// <summary>
/// The invocation for the event.
/// </summary>
/// <param name="eventName">The name of event.</param>
/// <param name="message">The message in bytes.</param>
/// <returns>The indicator for success.</returns>
private async Task <bool> ProcessEventAsync(string eventName, byte[] message)
{
var result = false;
if (!_subsManager.HasSubscriptionsForEvent(eventName))
{
return(false);
}
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
if (subscriptions == null || !subscriptions.Any())
{
return(false);
}
foreach (var subscription in subscriptions)
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = message;
var handler = scope.ResolveOptional(subscription.HandlerType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
var methodTask = concreteType.GetMethod("HandleAsync");
if (methodTask == null)
{
continue;
}
result = await InvokeMethodAsync(integrationEvent, handler, methodTask).ConfigureAwait(false);
}
}
return(result);
}
private async Task ProcessEvent(string eventName, string message, bool isFirstDispatch)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
using (var scope = _serviceProvider.CreateScope())
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
return;
}
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = System.Text.Json.JsonSerializer.Deserialize(message, eventType);
_preprocessAction?.Invoke(scope, integrationEvent);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
var handleMethod = concreteType.GetMethod(nameof(IIntegrationEventHandler <IntegrationEvent> .Handle));
await(Task) handleMethod.Invoke(handler, new[] { integrationEvent, isFirstDispatch });
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using var scope = ServiceProvider.CreateScope();
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
if (handler is null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.Deserialize(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
private async Task MessageHandler(ProcessMessageEventArgs arg)
{
var eventName = arg.Message.Subject;
if (_subscriptionManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = _serviceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subscriptionManager.GetEventTypeByName(eventName);
var messageData = Encoding.UTF8.GetString(arg.Message.Body);
var integrationEvent = JsonSerializer.Deserialize(messageData, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("HandleAsync").Invoke(handler, new object[] { integrationEvent });
await arg.CompleteMessageAsync(arg.Message);
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
/// TODO: log and break
if (!subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
return;
}
using (var scope = autofac.BeginLifetimeScope(AutofacScopeName))
{
var subscriptions = subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = subscriptionsManager.GetEventTypeByName(eventName);
var @event = JsonConvert.DeserializeObject(message, eventType);
var concreteEventType = typeof(IEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteEventType.GetMethod("Handle").Invoke(handler, new object[] { @event });
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(EventBusConstants.AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription) as IEventHandler;
if (handler == null)
{
continue;
}
var eventType = _subsManager.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
{
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = _serviceProvider.GetService(subscription.HandlerType) as IDynamicIntegrationEventHandler;
if (handler == null)
{
continue;
}
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
dynamic handler = _serviceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
dynamic integrationEvent = JsonConvert.DeserializeObject(message, eventType);
await handler.Handle(integrationEvent);
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogInformation($"process event: {eventName}");
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
_logger.LogInformation($"found eventhandler for: {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 IDynamicIntegrationEventHandler;
var handler = _objectFactory.GetInstance(subscription.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.When(eventData);
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
//var handler = scope.ResolveOptional(subscription.HandlerType);
var handler = _objectFactory.GetInstance(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("When").Invoke(handler, new object[] { integrationEvent });
}
}
//}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
if (_serviceProvider.GetService(subscription.HandlerType) is IDynamicIntegrationEventHandler handler)
{
dynamic eventData = JsonConvert.DeserializeObject <ExpandoObject>(message);
await handler.Handle(eventData);
}
}
else
{
var handler = _serviceProvider.GetService(subscription.HandlerType);
if (handler is not null)
{
var eventType = _subsManager.GetEventTypeByName(eventName);
object integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod(nameof(IDynamicIntegrationEventHandler.Handle)) !.Invoke(handler, new object[] { integrationEvent ! }) !;
private async Task ProcessEvent(string eventName, byte[] body, IBasicProperties properties)
{
var message = Encoding.UTF8.GetString(body);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handlers = _subsManager.GetHandlersForEvent(eventName);
foreach (var handlerfactory in handlers)
{
try
{
var handler = handlerfactory.DynamicInvoke();
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
catch
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
long retryCount = GetRetryCount(properties);
using (var channel = _persistentConnection.CreateModel())
{
if (retryCount > _retryCount)
{
// 重试次数大于3次，则自动加入到死信队列
var rollbackCount = retryCount - _retryCount;
if (rollbackCount < _rollbackCount)
{
IDictionary <String, Object> headers = new Dictionary <String, Object>();
if (!headers.ContainsKey("x-orig-routing-key"))
{
headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, eventName));
}
channel.BasicPublish(_exchanges[QueueConsumerMode.Fail], eventName, CreateOverrideProperties(properties, headers), body);
}
}
else
{
IDictionary <String, Object> headers = properties.Headers;
if (headers == null)
{
headers = new Dictionary <String, Object>();
}
if (!headers.ContainsKey("x-orig-routing-key"))
{
headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, eventName));
}
channel.BasicPublish(_exchanges[QueueConsumerMode.Retry], eventName, CreateOverrideProperties(properties, headers), body);
}
}
}
}
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
if (!_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
return(false);
}
var subscriptions = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
using (var scope = _serviceProvider.CreateScope())
{
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(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod(nameof(IIntegrationEventHandler <IntegrationEvent> .Handle)).Invoke(handler, new[] { integrationEvent });
}
}
return(true);
}
private async Task processEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
//Autofac recommends resolve a service from a lifetime scope instead of from the root container to avoid potential memory leak.
using (var scope = _autofac.BeginLifetimeScope(AUTOFACT_SCOPE_NAME))
{
var subs = _subsManager.GetHandlersForEvent(eventName);
foreach (var sub in subs)
{
if (sub.IsDynamic)
{
//Also a service may or may not registered, use conditional resolution methods such as ResolveOptional to resolve a service.
//It is dynamic, so you don’t really have a event type per se. You can only cast the handler to IDynamicIntegrationEventHandler
var handler = scope.ResolveOptional(sub.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
//The local variable eventType here is an instance of Type. You can’t use it in type casting directly;
//you need to use reflection.
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ResolveOptional(sub.HandlerType);
//Create an instance of a generic Type – the type of the event handler
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
/// <summary>
/// 处理事件
/// </summary>
/// <param name="eventName">事件名称</param>
/// <param name="message">消息</param>
/// <returns></returns>
private async Task ProcessEvent(string eventName, string message)
{
//事件有订阅者
if (subscriptionsManager.HasSubscriptionForEvent(eventName))
{
using (var scope = lifetimeScope.BeginLifetimeScope("dxqstudy_event_bus")) {
//获得事件所有订阅者，然后处理之
var subscriptions = subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
//按是否匿名事件不同处理
if (subscription.IsDynamic)
{
var handler = (IDynamicIntegrationEventHandler)scope.ResolveOptional(subscription.HandlerType);
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var eventType = subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ResolveOptional(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
//处理事件
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
protected virtual async Task TriggerHandlersAsync(string eventName, string eventData, List <Exception> exceptions)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
using (var scope = _serviceProvider.CreateScope())
{
foreach (var subscription in subscriptions)
{
try
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonUtils.DeserializeObject(eventData, eventType);
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subscriptionManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = Activator.CreateInstance(subscription.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var eventType = _subscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = Activator.CreateInstance(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
var processed = false;
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 integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
processed = true;
}
return(processed);
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _serviceProvider.CreateScope())
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
//var handler = scope.ServiceProvider.GetService(subscription.HandlerType) as IDynamicIntegrationEventHandler ; // scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
//dynamic eventData = JObject.Parse(message);
//await handler.Handle(eventData);
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = _serializer.DeSerialize(message, eventType);
var handler = scope.ServiceProvider.GetService(subscription.HandlerType); //scope.ResolveOptional(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessEventAsync(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = _serviceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationMessageHandler <>).MakeGenericType(eventType);
await InvokeAsync(concreteType, handler, (ICommand)integrationEvent);
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
