protected override async Task ConsumerReceived(object sender, BasicDeliverEventArgs eventArgs)
        {
            string[] result    = eventArgs.RoutingKey.Split('.');
            var      eventName = result.Length > 1 ? result[0] : eventArgs.RoutingKey;

            try
            {
                try
                {
                    var props      = eventArgs.BasicProperties;
                    var replyProps = ConsumerChannel.CreateBasicProperties();
                    replyProps.CorrelationId = props.CorrelationId;

                    var response = await ProcessEventRpc(eventArgs.RoutingKey, eventName, eventArgs.Body).ConfigureAwait(false);

                    var ms = new MemoryStream();
                    Serializer.Serialize <IIntegrationEventReply>(ms, response);
                    var body = ms.ToArray();
                    ConsumerChannel.BasicPublish(ExchangeDeclareParameters.ExchangeName, (string)response.RoutingKey, replyProps, body);
                }
                catch (Exception ex)
                {
                    Logger.LogError("CreateConsumerChannel RPC Received: " + ex.Message + " - " + ex.StackTrace);
                }
            }
            catch (Exception ex)
            {
                Logger.LogWarning("ConsumerReceived: " + eventName + " - " + ex.Message + " - " + ex.StackTrace);
            }

            // Even on exception we take the message off the queue.
            // in a REAL WORLD app this should be handled with a Dead Letter Exchange (DLX).
            // For more information see: https://www.rabbitmq.com/dlx.html
            ConsumerChannel.BasicAck(eventArgs.DeliveryTag, multiple: false);
        }
        /// <summary>
        /// Publishes a message to the queue using the QueueName as the routingKey.
        /// </summary>
        /// <typeparam name="T">The type of the message object.</typeparam>
        /// <param name="msg">The message.</param>
        /// <param name="exchange">[Optional] The exchange name.</param>
        /// <param name="delayMilliseconds">[Optional] The delay milliseconds before the message is available in the queue.</param>
        private void PublishMessage <T> (T msg, string exchange, string queueName, int delayMilliseconds)
        {
            // set persistent property
            IBasicProperties basicProperties = null;

            if (_publishPersistent)
            {
                if (basicProperties == null)
                {
                    basicProperties = ConsumerChannel.CreateBasicProperties();
                }
                basicProperties.Persistent = _publishPersistent;
            }

            if (_retryDelayMilliseconds > 0)
            {
                if (basicProperties == null)
                {
                    basicProperties = ConsumerChannel.CreateBasicProperties();
                }
                basicProperties.AddHeader("x-delay", _retryDelayMilliseconds);
            }

            // publish message
            PublishChannel.BasicPublish(exchange: exchange ?? "",
                                        routingKey: queueName,
                                        basicProperties: basicProperties,
                                        body: GetMessageContent(msg));
        }