protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncHandlerFactory, Type eventType, object eventData, List <Exception> exceptions)
{
using (var eventHandlerWrapper = asyncHandlerFactory.GetHandler())
{
try
{
var handlerType = eventHandlerWrapper.EventHandler.GetType();
if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(IMQEventHandler <>)))
{
var method = typeof(IMQEventHandler <>)
.MakeGenericType(eventType)
.GetMethod(
nameof(IMQEventHandler <object> .HandleEventAsync),
new[] { eventType }
);
await((Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData }));
}
else
{
throw new Exception("The object instance is not an event handler. Object type: " + handlerType.AssemblyQualifiedName);
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
/// <summary>
/// 重写以实现异步触发事件的执行
/// </summary>
/// <param name="factory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="wait">是否等待结果返回</param>
/// <returns></returns>
protected virtual Task InvokeHandlerAsync(IEventHandlerFactory factory, Type eventType, IEventData eventData, bool wait = true)
{
EventHandlerDisposeWrapper handlerWrapper = factory.GetHandler();
IEventHandler handler = handlerWrapper.EventHandler;
try
{
if (handler == null)
{
Logger.LogWarning($"事件源“{eventData.GetType()}”的事件处理器无法找到");
return(Task.FromResult(0));
}
if (!handler.CanHandle(eventData))
{
return(Task.FromResult(0));
}
if (wait)
{
return(RunAsync(factory, handler, eventType, eventData));
}
Task.Run(async() =>
{
await RunAsync(factory, handler, eventType, eventData);
});
return(Task.FromResult(0));
}
finally
{
handlerWrapper.Dispose();
}
}
/// <summary>
/// 重写以实现触发事件的执行
/// </summary>
/// <param name="factory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="wait">是否等待结果返回</param>
protected void InvokeHandler(IEventHandlerFactory factory, Type eventType, IEventData eventData, bool wait = true)
{
EventHandlerDisposeWrapper handlerWrapper = factory.GetHandler();
IEventHandler handler = handlerWrapper.EventHandler;
try
{
if (handler == null)
{
Logger.LogWarning($"事件源“{eventData.GetType()}”的事件处理器无法找到");
return;
}
if (!handler.CanHandle(eventData))
{
return;
}
if (wait)
{
Run(factory, handler, eventType, eventData);
}
else
{
Task.Run(() =>
{
Run(factory, handler, eventType, eventData);
});
}
}
finally
{
handlerWrapper.Dispose();
}
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {eventName}", eventName);
if (_subsManager.IncludeEventTypeForEventName(eventName))
{
var eventHandleTypes = _subsManager.TryGetEventHandlerTypes(eventName);
foreach (var eventHandleType in eventHandleTypes)
{
var handlerInstance = _eventHandlerFactory.GetHandler(eventHandleType);
var eventType = _subsManager.TryGetEventTypeForEventName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
var method = concreteType.GetMethod("Handle");
if (method != null)
{
await(Task) method.Invoke(handlerInstance, new[] { integrationEvent });
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {eventName}", eventName);
}
}
private async Task TriggerAsyncHandlingException(IEventHandlerFactory asyncHandlerFactory, Type eventType, IEventData eventData, List <Exception> exceptions)
{
var asyncEventHandler = asyncHandlerFactory.GetHandler();
try
{
if (asyncEventHandler == null)
{
throw new ArgumentNullException($"Registered event handler for event type {eventType.Name} 为空!");
}
var asyncHandlerType = typeof(IAsyncEventHandler <>).MakeGenericType(eventType);
var method = asyncHandlerType.GetMethod(
"HandleEventAsync",
new[] { eventType }
);
await(Task) method.Invoke(asyncEventHandler, new object[] { eventData });
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
finally
{
asyncHandlerFactory.ReleaseHandler(asyncEventHandler);
}
}
/// <summary>
/// 重写以实现触发事件的执行
/// </summary>
/// <param name="factory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="wait">是否等待结果返回</param>
protected void InvokeHandler(IEventHandlerFactory factory, Type eventType, IEventData eventData, bool wait = true)
{
IEventHandler handler = factory.GetHandler();
if (handler == null)
{
_Logger.LogWarning($"事件源“{eventData.GetType()}”的事件处理器无法找到");
return;
}
if (!handler.CanHandle(eventData))
{
return;
}
if (wait)
{
Run(factory, handler, eventType, eventData);
}
else
{
Task.Run(() =>
{
Run(factory, handler, eventType, eventData);
});
}
}
public void publish <T>(T @event) where T : Event
{
var handler = _eventHandlerFactory.GetHandler <T>();
if (handler == null)
{
throw new InvalidOperationException($"unRegister Handlers {nameof(T)}");
}
handler.Handle(@event);
}
protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncHandlerFactory, Type eventType,
object eventData, List <Exception> exceptions, InboxConfig inboxConfig = null)
{
using (var eventHandlerWrapper = asyncHandlerFactory.GetHandler())
{
try
{
var handlerType = eventHandlerWrapper.EventHandler.GetType();
if (inboxConfig?.HandlerSelector != null &&
!inboxConfig.HandlerSelector(handlerType))
{
return;
}
using (CurrentTenant.Change(GetEventDataTenantId(eventData)))
{
if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(ILocalEventHandler <>)))
{
var method = typeof(ILocalEventHandler <>)
.MakeGenericType(eventType)
.GetMethod(
nameof(ILocalEventHandler <object> .HandleEventAsync),
new[] { eventType }
);
await((Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData }));
}
else if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(IDistributedEventHandler <>)))
{
var method = typeof(IDistributedEventHandler <>)
.MakeGenericType(eventType)
.GetMethod(
nameof(IDistributedEventHandler <object> .HandleEventAsync),
new[] { eventType }
);
await((Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData }));
}
else
{
throw new AbpException("The object instance is not an event handler. Object type: " + handlerType.AssemblyQualifiedName);
}
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
/// <summary>
/// 触发
/// </summary>
/// <param name="asyncHandlerFactory"></param>
/// <param name="eventType"></param>
/// <param name="eventData"></param>
/// <param name="exceptions"></param>
/// <returns></returns>
protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncHandlerFactory, Type eventType, object eventData, List <Exception> exceptions)
{
using var eventHandlerWrapper = asyncHandlerFactory.GetHandler();
try
{
// 获得事件处理器的类型。
var handlerType = eventHandlerWrapper.EventHandler.GetType();
using (CurrentTenant.Change(GetEventDataTenantId(eventData)))
{
// 判断事件处理器是本地事件还是分布式事件。
if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(ILocalEventHandler <>)))
{
// 获得方法定义。
var method = typeof(ILocalEventHandler <>)
.MakeGenericType(eventType)
.GetMethod(nameof(ILocalEventHandler <object> .HandleEventAsync), new[] { eventType });
// 使用工厂创建的实例调用方法。
await(Task) method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData });
}
else if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(IDistributedEventHandler <>)))
{
// 获得方法定义。
var method = typeof(IDistributedEventHandler <>)
.MakeGenericType(eventType)
.GetMethod(nameof(IDistributedEventHandler <object> .HandleEventAsync), new[] { eventType });
// 使用工厂创建的实例调用方法。
await(Task) method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData });
}
else
{
// 如果都不是，则说明类型不正确，抛出异常。
throw new Exception("The object instance is not an event handler. Object type: " + handlerType.AssemblyQualifiedName);
}
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
/// <summary>
/// 重写以实现异步触发事件的执行
/// </summary>
/// <param name="factory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <returns></returns>
protected virtual async Task InvokeHandlerAsync(IEventHandlerFactory factory, Type eventType, IEventData eventData)
{
EventHandlerDisposeWrapper handlerWrapper = factory.GetHandler();
IEventHandler handler = handlerWrapper.EventHandler;
try
{
if (handler == null)
{
Logger.LogWarning($"事件源“{eventData.GetType()}”的事件处理器无法找到");
return;
}
await RunAsync(handler, eventType, eventData);
}
finally
{
handlerWrapper.Dispose();
}
}
protected override void Publish(Type eventType, IntegrationEvent eventDate)
{
var exceptions = new List <Exception>();
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
if (_subsManager.IncludeEventTypeForEventName(eventName))
{
var eventHandleTypes = _subsManager.TryGetEventHandlerTypes(eventName);
foreach (var eventHandleType in eventHandleTypes)
{
try
{
var handlerInstance = _eventHandlerFactory.GetHandler(eventHandleType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
var method = concreteType.GetMethod("Handle");
if (method != null)
{
((Task)method.Invoke(handlerInstance, new object[] { eventDate })).GetAwaiter().GetResult();
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
else
{
_logger.LogWarning("No subscription for local memory event: {eventName}", eventName);
}
if (exceptions.Any())
{
throw new AggregateException(
"More than one error has occurred while triggering the event: " + eventType, exceptions);
}
}
/// <summary>
/// 触发事件处理器
/// </summary>
/// <param name="asyncEventHandlerFactory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="exceptions">异常列表</param>
protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncEventHandlerFactory, Type eventType, object eventData, List <Exception> exceptions)
{
using (var eventHandlerWrapper = asyncEventHandlerFactory.GetHandler())
{
try
{
var handlerType = eventHandlerWrapper.EventHandler.GetType();
// 本地事件处理器
if (Types.IsGenericImplementation(handlerType, typeof(ILocalEventHandler <>)))
{
var method = typeof(ILocalEventHandler <>)
.MakeGenericType(eventType)
.GetMethod(nameof(ILocalEventHandler <object> .HandleAsync), new[] { eventType });
if (method == null)
{
return;
}
var result = method.Invoke(eventHandlerWrapper.EventHandler, new object[] { eventData });
if (result == null)
{
return;
}
await(Task) result;
}
else
{
throw new Warning(
$"The object instance is not an event handler. Object type: {handlerType.AssemblyQualifiedName}");
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
public async Task PublishAsync <T>(T evnt) where T : Event
{
IEventHandler <T> handler = _factory.GetHandler <T>();
await handler.HandleAsync(evnt);
}
