Example #1
0
        private void PublishCommandMessage(object message, string queueName, string key, Guid correlationId, string exchangeName)
        {
            var eventMessage = new EventMessage
            {
                CorrelationId  = correlationId,
                RoutingKey     = key,
                Type           = key,
                JsonMessage    = JsonConvert.SerializeObject(message),
                ReplyQueueName = _callbackQueue
            };

            switch (exchangeName)
            {
            case null:
                _busProvider.BasicTopicBind(queueName, key);
                _busProvider.BasicPublish(eventMessage);
                break;

            case "":     // "" is actually a exchange of type 'direct' in rabbitMQ. No topicbind needed in this case
                _busProvider.BasicPublish(eventMessage, exchangeName);
                break;

            default:
                _busProvider.BasicTopicBind(queueName, key, exchangeName);
                _busProvider.BasicPublish(eventMessage, exchangeName);
                break;
            }
        }
        private void HandleReceivedCommand(CommandReceivedCallback callback, EventMessage receivedEventMessage, Type parameterType, string exchangeName)
        {
            Task.Run(async() =>
            {
                object response = null;
                var isError     = false;

                var replyKey = $"{receivedEventMessage.RoutingKey}.Reply";
                _busProvider.BasicTopicBind(receivedEventMessage.ReplyQueueName, replyKey);

                try
                {
                    var deserializedParameter = JsonConvert.DeserializeObject(receivedEventMessage.JsonMessage, parameterType);
                    response = await callback(deserializedParameter);
                }
                catch (TargetInvocationException ex)
                {
                    response = new CommandPublisherException(ex.InnerException.Message, ex.InnerException);
                    isError  = true;
                }
                catch (Exception ex)
                {
                    response = new CommandPublisherException(ex.Message, ex);
                    isError  = true;
                }
                finally
                {
                    if (exchangeName == null)
                    {
                        _busProvider.BasicPublish(new EventMessage
                        {
                            CorrelationId = receivedEventMessage.CorrelationId,
                            IsError       = isError,
                            JsonMessage   = JsonConvert.SerializeObject(response),
                            Type          = replyKey,
                            RoutingKey    = replyKey
                        });
                    }
                    else
                    {
                        _busProvider.BasicPublish(new EventMessage
                        {
                            CorrelationId = receivedEventMessage.CorrelationId,
                            IsError       = isError,
                            JsonMessage   = JsonConvert.SerializeObject(response),
                            Type          = replyKey,
                            RoutingKey    = replyKey
                        },
                                                  exchangeName);
                    }

                    _busProvider.BasicAcknowledge(receivedEventMessage.DeliveryTag, false);
                }
            });
        }
        public Task SendEventAsync(object message, string routingKey)
        {
            EnsureArg.IsNotNull(message, nameof(message));
            EnsureArg.IsNotNullOrWhiteSpace(routingKey, nameof(routingKey));

            return(Task.Run(() =>
            {
                var eventMessage = new EventMessage
                {
                    JsonMessage = JsonConvert.SerializeObject(message),
                    RoutingKey = routingKey
                };

                _busProvider.BasicPublish(eventMessage);
            }));
        }