private async ValueTask ProcessRichMessageHandlingExceptionAsync(IMessageScope scope, IMessageHandlerFactory asyncHandlerFactory, Type messageType, IMessage message, IRichMessageDescriptor descriptor, List <Exception> exceptions) { var handlerInstance = asyncHandlerFactory.GetHandler(scope); try { if (handlerInstance == null) { throw new ArgumentNullException($"Registered async rich message handler for message type {messageType.Name} is null!"); } var ifType = typeof(IAsyncRichMessageHandler <>).MakeGenericType(messageType); var method = ifType.GetMethod( nameof(IAsyncRichMessageHandler <IMessage> .HandleMessageAsync), new[] { messageType, typeof(IRichMessageDescriptor) } ); await(ValueTask) method.Invoke(handlerInstance, new object[] { message, descriptor }); } catch (TargetInvocationException ex) { exceptions.Add(ex.InnerException); } catch (Exception ex) { exceptions.Add(ex); } finally { asyncHandlerFactory.ReleaseHandler(scope, handlerInstance); } }
private async ValueTask ProcessMessageHandlingExceptionAsync(IMessageScope scope, IMessageHandlerFactory asyncHandlerFactory, Type messageType, IMessage message, List <Exception> exceptions) { var asyncEventHandler = asyncHandlerFactory.GetHandler(scope); try { if (asyncEventHandler == null) { throw new ArgumentNullException($"Registered async message handler for message type {messageType.Name} is null!"); } var asyncHandlerType = typeof(IAsyncMessageHandler <>).MakeGenericType(messageType); var method = asyncHandlerType.GetMethod( nameof(IAsyncMessageHandler <IMessage> .HandleMessageAsync), new[] { messageType } ); await(ValueTask) method.Invoke(asyncEventHandler, new object[] { message }); } catch (TargetInvocationException ex) { exceptions.Add(ex.InnerException); } catch (Exception ex) { exceptions.Add(ex); } finally { asyncHandlerFactory.ReleaseHandler(scope, asyncEventHandler); } }
private void ProcessMessageHandlingException(IMessageScope scope, IMessageHandlerFactory handlerFactory, Type messageType, IMessage message, List <Exception> exceptions) { var eventHandler = handlerFactory.GetHandler(scope); try { if (eventHandler == null) { throw new ArgumentNullException($"Registered message handler for message type {messageType.Name} is null!"); } var handlerType = typeof(IMessageHandler <>).MakeGenericType(messageType); var method = handlerType.GetMethod( nameof(IMessageHandler <IMessage> .HandleMessage), new[] { messageType } ); method.Invoke(eventHandler, new object[] { message }); } catch (TargetInvocationException ex) { exceptions.Add(ex.InnerException); } catch (Exception ex) { exceptions.Add(ex); } finally { handlerFactory.ReleaseHandler(scope, eventHandler); } }
public async ValueTask <bool> CallAsync(IMessageScope scope, IMessageHandlerFactory handlerFactory, IMessage message, IRichMessageDescriptor messageDescriptor, List <Exception> exceptions = null, CancellationToken cancellationToken = default) { var handlerDescriptor = handlerFactory.GetHandlerDescriptor(); IMessageHandler handler = null; try { handler = handlerFactory.GetHandler(scope); if (handlerDescriptor.IsAsync) { await GetOrCreateAsyncHandlerCallCache(handlerDescriptor).Invoke(handler, message, messageDescriptor); } else { GetOrCreateSyncHandlerCallCache(handlerDescriptor).Invoke(handler, message, messageDescriptor); } } catch (TargetInvocationException e) { exceptions?.Add(e.InnerException); return(false); } catch (Exception e) { exceptions?.Add(e); return(false); } finally { if (handler != null) { handlerFactory.ReleaseHandler(scope, handler); } } return(true); }