C# IModel.BasicCancel方法代码示例

        //TODO: REMOVE LATER: This method is never called because the DirectReplyToStrategy is used when the client decides to use
        //the direct reply to feature.
        /// <summary>
        /// Discovers the Direct reply-to queue name ( https://www.rabbitmq.com/direct-reply-to.html ) by messaging itself.
        /// </summary>
        private static string DiscoverDirectReplyToQueueName(IModel channel, string indirectReplyToQueueName)
        {
            DeclareIndirectReplyToQueue(channel, indirectReplyToQueueName);

            var receiver = new ConcurrentQueueingConsumer(channel);
            var receiverTag = channel.BasicConsume(indirectReplyToQueueName, true, receiver);

            channel.BasicPublish(String.Empty, indirectReplyToQueueName, true, new BasicProperties { ReplyTo = RPCStrategyHelpers.DIRECT_REPLY_TO_QUEUENAME_ARG }, new byte[0]);

            BasicDeliverEventArgs delivery;
            using (ManualResetEventSlim messageReturned = new ManualResetEventSlim())
            {
                EventHandler<BasicReturnEventArgs> returnHandler = null;
                Interlocked.Exchange(ref returnHandler, (a, e) => { messageReturned.Set(); try { receiver.Model.BasicReturn -= returnHandler; } catch { } });
                receiver.Model.BasicReturn += returnHandler;

                System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
                watch.Start();
                while (!receiver.TryInstantDequeue(out delivery, throwIfClosed: false))
                {
                    Thread.Sleep(1);
                    if (watch.Elapsed > TimeSpan.FromSeconds(10) || messageReturned.IsSet)
                    {
                        break;
                    }
                }
                watch.Stop();

                if (!messageReturned.IsSet)
                {
                    try
                    {
                        receiver.Model.BasicReturn -= returnHandler;
                    }
                    catch { }
                }

                try
                {
                    channel.BasicCancel(receiverTag);
                }
                catch { }
            }

            if (delivery == null)
            {
                throw new InvalidOperationException("Unable to determine direct reply-to queue name.");
            }

            var result = delivery.BasicProperties.ReplyTo;
            if (result == null || result == RPCStrategyHelpers.DIRECT_REPLY_TO_QUEUENAME_ARG || !result.StartsWith(RPCStrategyHelpers.DIRECT_REPLY_TO_QUEUENAME_ARG))
            {
                throw new InvalidOperationException("Discovered direct reply-to queue name (" + (result ?? "null") + ") was not in expected format.");
            }

            return result;
        }

        /// <summary>
        /// Close the message consumer.
        /// </summary>
        /// <param name="channel">
        /// The channel.
        /// </param>
        /// <param name="consumerTag">
        /// The consumer tag.
        /// </param>
        /// <param name="transactional">
        /// The transactional.
        /// </param>
        /// <exception cref="SystemException">
        /// </exception>
        public static void CloseMessageConsumer(IModel channel, string consumerTag, bool transactional)
        {
            if (!channel.IsOpen)
            {
                return;
            }

            try
            {
                channel.BasicCancel(consumerTag);
                if (transactional)
                {
                    /*
                     * Re-queue in-flight messages if any (after the consumer is cancelled to prevent the broker from simply
                     * sending them back to us). Does not require a tx.commit.
                     */
                    channel.BasicRecover(true);
                }
            }
            catch (Exception ex)
            {
                throw ConvertRabbitAccessException(ex);
            }
        }

 public static void CloseMessageConsumer(IModel channel, string consumerTag)
 {
     channel.BasicCancel(consumerTag);
 }