C# IModel.BasicNack方法代码示例

		public void Process(
			IModel channel,
			BasicDeliverEventArgs message)
		{
			var _logMessageContext = string.Format("type header = {0}, message Id = {1}, correlation Id = {2} and delivery tag = {3}",
				message.BasicProperties.Type,
				message.BasicProperties.MessageId,
				message.BasicProperties.CorrelationId,
				message.DeliveryTag);
			this.c_logger.DebugFormat("Process About to handle message, {0}", _logMessageContext);

			if (!this.c_configuration.MessageConsumers.HasConfiguration(message.BasicProperties.Type))
			{
				this.c_logger.DebugFormat("Process No match found for message, {0}", _logMessageContext);
				//pending - see errored below
				channel.BasicNack(message.DeliveryTag, false, false);
				return;
			}

			var _configuration = this.c_configuration.MessageConsumers[message.BasicProperties.Type];
			var _actionResult = ConsumerHandlerResult.None;
			try
			{
				this.c_logger.DebugFormat("Process About to deserialze message for message, {0}", _logMessageContext);
				var _messageJson = Encoding.UTF8.GetString(message.Body);
				var _message = JsonConvert.DeserializeObject(_messageJson, _configuration.Type);

				this.c_logger.DebugFormat("Process About to invoke action for message, {0}", _logMessageContext);
				_actionResult = _configuration.Action(_message as Message);
			}
			catch (Exception exception)
			{
				this.c_logger.WarnFormat("Process Encountered error for message {0} Error: {1}", _logMessageContext, exception.InstrumentationString());
				_actionResult = ConsumerHandlerResult.Errored;
			}
			this.c_logger.DebugFormat("Process Completed processing for message, {0}, result is {1}", _logMessageContext, _actionResult);

			if (_actionResult == ConsumerHandlerResult.Errored)
			{
				//pending - should i use configuration properties
				// Nack, do not requeue, dead letter the message if dead letter exchange configured for the queue
				channel.BasicNack(message.DeliveryTag, false, false);
			}
			else if (_actionResult == ConsumerHandlerResult.Completed)
			{
				channel.BasicAck(message.DeliveryTag, false);
			}
			else if (_actionResult == ConsumerHandlerResult.Requeue)
			{
				//pending does this make sense ?
				channel.BasicReject(message.DeliveryTag, true);
			}

			this.c_logger.DebugFormat("Process Completed handling message, {0}, Result is {1}", _logMessageContext, _actionResult);
		}

        /// <summary>
        /// Perform a rollback, handling rollback excepitons properly.
        /// </summary>
        /// <param name="channel">
        /// The channel to rollback.
        /// </param>
        /// <param name="message">
        /// The message.
        /// </param>
        /// <param name="ex">
        /// The thrown application exception.
        /// </param>
        protected virtual void RollbackOnExceptionIfNecessary(IModel channel, Message message, Exception ex)
        {
            var ackRequired = !this.AcknowledgeMode.IsAutoAck() && !this.AcknowledgeMode.IsManual();
            try
            {
                if (this.IsChannelTransacted)
                {
                    if (this.logger.IsDebugEnabled)
                    {
                        this.logger.Debug("Initiating transaction rollback on application exception" + ex);
                    }

                    RabbitUtils.RollbackIfNecessary(channel);
                }

                if (message != null)
                {
                    if (ackRequired)
                    {
                        if (this.logger.IsDebugEnabled)
                        {
                            this.logger.Debug("Rejecting message");
                        }

                        // channel.BasicReject((ulong)message.MessageProperties.DeliveryTag, true);
                        channel.BasicNack((ulong)message.MessageProperties.DeliveryTag, true, true);
                    }

                    if (this.IsChannelTransacted)
                    {
                        // Need to commit the reject (=nack)
                        RabbitUtils.CommitIfNecessary(channel);
                    }
                }
            }
            catch (Exception e)
            {
                this.logger.Error("Application exception overriden by rollback exception", ex);
                throw;
            }
        }

 private AckResult ExceptionAckStrategy(IModel model, ulong deliveryTag, PostExceptionAckStrategy strategy)
 {
     switch (strategy)
     {
         case PostExceptionAckStrategy.ShouldAck:
             model.BasicAck(deliveryTag, false);
             return AckResult.Ack;
         case PostExceptionAckStrategy.ShouldNackWithoutRequeue:
             model.BasicNack(deliveryTag, false, false);
             return AckResult.Nack;
         case PostExceptionAckStrategy.ShouldNackWithRequeue:
             model.BasicNack(deliveryTag, false, true);
             return AckResult.Nack;
         case PostExceptionAckStrategy.DoNothing:
             return AckResult.Nothing;
         default:
             return AckResult.Nothing;
     }
 }

        private void HandleDelivery(IModel channel, BasicDeliverEventArgs delivery, CancellationToken cancellationToken)
        {
            try
            {
                // Put on the thread pool to avoid deadlock
                var acknowleged = Task.Run(() => DispatchToListener(delivery, cancellationToken),
                    cancellationToken).Result;

                if (acknowleged)
                {
                    Log.DebugFormat(
                        "Acknowledging message {0} from RabbitMQ queue \"{1}\" on channel {2}...",
                        delivery.DeliveryTag, _queueName, channel.ChannelNumber);

                    channel.BasicAck(delivery.DeliveryTag, false);
                }
                else
                {
                    Log.DebugFormat(
                        "Message {0} from RabbitMQ queue \"{1}\" received on channel {2} not acknowledged",
                        delivery.DeliveryTag, _queueName, channel.ChannelNumber);

                    // Add 1 to the header value because the number of attempts will be zero
                    // on the first try
                    var currentAttempt = delivery.BasicProperties.GetDeliveryAttempts() + 1;
                    if (currentAttempt < _maxAttempts)
                    {
                        Log.DebugFormat(
                            "Re-publishing message {0} to retry queue \"{1}\" for redelivery...",
                            delivery.DeliveryTag, _retryQueueName);

                        var retryProperties = delivery.BasicProperties;
                        retryProperties.IncrementDeliveryAttempts();
                        channel.BasicPublish(_retryExchange, "", retryProperties, delivery.Body);
                    }
                    else
                    {
                        Log.WarnFormat(
                            "Maximum delivery attempts for message {0} exceeded.  Sending NACK on channel {1}...",
                            delivery.DeliveryTag, channel.ChannelNumber);

                        channel.BasicNack(delivery.DeliveryTag, false, false);
                    }
                }
            }
            catch (Exception e)
            {
                Log.ErrorFormat("Error processing message {0} from RabbitMQ queue \"{1}\" on channel {2}", e,
                    delivery.DeliveryTag, _queueName, channel.ChannelNumber);

                // Due to the complexity of managing retry counts and delays in
                // RabbitMQ, retries are handled in the HandleDelivery method.
                // Therefore if we get to this point, we've done the best we
                // could.
                channel.BasicNack(delivery.DeliveryTag, false, false);
            }
        }

 private void ExceptionAckStrategy(IModel model, ulong deliveryTag)
 {
     switch (consumerErrorStrategy.PostExceptionAckStrategy())
     {
         case PostExceptionAckStrategy.ShouldAck:
             model.BasicAck(deliveryTag, false);
             break;
         case PostExceptionAckStrategy.ShouldNackWithoutRequeue:
             model.BasicNack(deliveryTag, false, false);
             break;
         case PostExceptionAckStrategy.ShouldNackWithRequeue:
             model.BasicNack(deliveryTag, false, true);
             break;
         case PostExceptionAckStrategy.DoNothing:
             break;
     }
 }

        private void ContinueReceiving(QueueingBasicConsumer consumer, Guid channelId, IModel channel)
        {
            try
            {
                while (IsReceiving)
                {
                    var ea = consumer.Queue.Dequeue();
                    var body = ea.Body;
                    var message = _encode.GetString(body);

                    Logger.Debug("[{0}]�ѽ��յ���Ϣ��{1}", channelId, message);

                    var success = HandleMessage(message);

                    if (success)
                    {
                        Logger.Debug("[{0}]����ɹ����ѷ��ͻ�ִ��Ϣ(Ack)��", channelId);

                        channel.BasicAck(ea.DeliveryTag, false);
                    }
                    else
                    {
                        Logger.Debug("[{0}]����ʧ�ܣ��ѷ��ͻ�ִ��Ϣ(Nack)��׼�����½��ܴ�����Ϣ��", channelId);

                        channel.BasicNack(ea.DeliveryTag, false, true);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new MqException("ִ�н�����Ϣʧ�ܡ�", ex);
            }
        }

        internal static void TryAckOrNack(string consumerTag, bool ack, IModel channel, ulong deliveryTag, bool multiple, bool requeue, IRabbitWatcher watcher = null)
        {
            try
            {
                if (channel == null)
                {
                    (watcher ?? Global.DefaultWatcher).WarnFormat("Trying ack/nack msg but the Channel is null, will not do anything");
                }
                else if (!channel.IsOpen)
                {
                    (watcher ?? Global.DefaultWatcher).WarnFormat("Trying ack/nack msg but the Channel is not open, will not do anything");
                }
                else
                {
                    if (ack)
                    {
                        channel.BasicAck(deliveryTag, multiple);
                    }
                    else
                    {
                        channel.BasicNack(deliveryTag, multiple, requeue);
                    }

                    lock (OutstandingDeliveryTags)
                    {
                        if (OutstandingDeliveryTags.ContainsKey(consumerTag))
                        {
                            if (deliveryTag == 0)
                            {
                                // Ack/Nack all out standing
                                OutstandingDeliveryTags[consumerTag].Clear();
                            }
                            else if (multiple)
                            {
                                // Ack/Nack all up to
                                OutstandingDeliveryTags[consumerTag].RemoveAll(x => x <= deliveryTag);
                                //(watcher ?? Global.DefaultWatcher).InfoFormat("Ack/Nack multiple tags <= {0} for consumer {1}", deliveryTag, consumerTag);
                                //(watcher ?? Global.DefaultWatcher).InfoFormat("Outstanding tags {0}", String.Join(",", OutstandingDeliveryTags[consumerTag].OrderBy(x => x)));
                            }
                            else
                            {
                                // Ack/Nack only 1 single tagtag
                                OutstandingDeliveryTags[consumerTag].Remove(deliveryTag);
                            }
                        }
                    }
                }
            }
            catch (AlreadyClosedException alreadyClosedException)
            {
                (watcher ?? Global.DefaultWatcher).WarnFormat(FailedToAckMessage, alreadyClosedException.Message);
            }
            catch (IOException ioException)
            {
                (watcher ?? Global.DefaultWatcher).WarnFormat(FailedToAckMessage, ioException.Message);
            }
        }

		async void HandleMessage(Subscription s, byte[] data, ulong tag, IModel model)
		{
			var status = false;
			try
			{
				await s.Handler(data);
				status = true;
			}
			catch (Exception e)
			{
				_logger("Exception while executing message handler", e);
			}
			SafeExec(_queue.EnqueueTask(m =>
			{
				if (m != model) //Reconnect occured, its not the same connection anymore
					return;
				if (status)
					model.BasicAck(tag, false);
				else
					model.BasicNack(tag, false, true);
			}));


		}