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 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 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); } }
internal string Respond(Stream requestBody, ConfigureModel persistable, string provider) { var requestXml = new StreamReader(requestBody).ReadToEnd(); //Hack to Log Xml as Exception. new LogEvent(requestXml).Raise(); Console.WriteLine(requestXml); return(_messageHandlerFactory.GetHandler(requestXml, provider).HandleResponse(requestXml, persistable)); }
private async Task HandleNextMessageAsync(string messageEnvelopeAsString) { try { var payload = JsonConvert.DeserializeObject <MessageBrokerEnvelope <NewOrderDto> >(messageEnvelopeAsString); var handler = _messageHandlerFactory.GetHandler(MessageTypes.NewOrder); await handler.ExecuteAsync(payload); } catch (Exception ex) { throw new Exception("Message processing failed.", ex); } }
private IMessageHandler GetHandler(IMessage message) { Contract.Requires(message != null); Contract.Ensures(Contract.Result <IMessageHandler>() != null); try { // get handler from factory return(_handlerFactory.GetHandler(message.GetType())); } catch (Exception e) { // rethrow exception has a message handling exception throw new MessageHandlingException(message, e, "Could not get a message handler for message."); } }
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); }
public void HandleMessage(IQueueMessage message) { var handler = _messageHandlerFactory.GetHandler(message.MessageType); handler.HandleMessage(message); }
public void CanGetHandlerForRegisteredMessage() { Assert.IsNotNull(_factory.GetHandler(typeof(Message1))); }