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); }