C# NamespaceManager.QueueExistsAsync方法代码示例

 private async static Task QueueShouldExistAsync(NamespaceManager ns, QueueDescription queueDescription)
 {
     if (!await ns.QueueExistsAsync(queueDescription.Path))
     {
         throw new MessagingEntityNotFoundException("Queue: " + queueDescription.Path);
     }
 }

        private async static Task QueueCreateAsync(NamespaceManager ns, QueueDescription queueDescription)
        {
            if (!await ns.QueueExistsAsync(queueDescription.Path))
            {
                await ns.CreateQueueAsync(queueDescription);

                ServiceBusEventSource.Log.CreatedQueue(ns.Address.ToString(), queueDescription.Path);
            }
        }

        public async Task Run(string namespaceAddress, string manageToken)
        {
            Console.WriteLine("\nCreating topology\n");
            this.sharedAccessRuleKey = SharedAccessAuthorizationRule.GenerateRandomKey();
            var namespaceManageTokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(manageToken);

            // Create namespace manager and create destination queue with a SAS rule that allows sending to that queue.
            var namespaceManager = new NamespaceManager(namespaceAddress, namespaceManageTokenProvider);

            var targetQueue = new QueueDescription("TargetQueue")
            {
                Authorization = { new SharedAccessAuthorizationRule("SendKey", this.sharedAccessRuleKey, new[] { AccessRights.Send }) },
            };

            targetQueue = (await namespaceManager.QueueExistsAsync(targetQueue.Path))
                ? await namespaceManager.UpdateQueueAsync(targetQueue)
                : await namespaceManager.CreateQueueAsync(targetQueue);

            var topic = new TopicDescription("SourceTopic")
            {
                Authorization = { new SharedAccessAuthorizationRule("SendKey", this.sharedAccessRuleKey, new[] { AccessRights.Send }) }
            };
            topic = (await namespaceManager.TopicExistsAsync(topic.Path))
                ? await namespaceManager.UpdateTopicAsync(topic)
                : await namespaceManager.CreateTopicAsync(topic);
            var forwardingSubscription = namespaceManager.CreateSubscription(
                new SubscriptionDescription(topic.Path, "Sub1")
                {
                    ForwardTo = targetQueue.Path
                });

            var forwardingQueue = new QueueDescription("SourceQueue")
            {
                ForwardTo = targetQueue.Path,
                Authorization =
                {
                    new SharedAccessAuthorizationRule(
                        "SendKey",
                        this.sharedAccessRuleKey,
                        new[] {AccessRights.Send})
                }
            };
            forwardingQueue = (await namespaceManager.QueueExistsAsync(forwardingQueue.Path))
                ? await namespaceManager.UpdateQueueAsync(forwardingQueue)
                : await namespaceManager.CreateQueueAsync(forwardingQueue);


            Console.WriteLine("\nSending messages\n");

            var topicFactory = MessagingFactory.Create(namespaceAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider("SendKey", this.sharedAccessRuleKey));
            var topicSender = await topicFactory.CreateMessageSenderAsync(topic.Path);
            await topicSender.SendAsync(CreateMessage("M1"));

            var queueFactory = MessagingFactory.Create(namespaceAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider("SendKey", this.sharedAccessRuleKey));
            var queueSender = await queueFactory.CreateMessageSenderAsync(forwardingQueue.Path);
            await queueSender.SendAsync(CreateMessage("M1"));


            var messagingFactory = MessagingFactory.Create(namespaceAddress, namespaceManageTokenProvider);
            var targetQueueReceiver = messagingFactory.CreateQueueClient(targetQueue.Path);
            while (true)
            {
                var message = await targetQueueReceiver.ReceiveAsync(TimeSpan.FromSeconds(10));
                if (message != null)
                {
                    await this.PrintReceivedMessage(message);
                    await message.CompleteAsync();
                }
                else
                {
                    break;
                }
            }
            await targetQueueReceiver.CloseAsync();

            Console.WriteLine("\nPress ENTER to delete topics and exit\n");
            Console.ReadLine();
            messagingFactory.Close();
            Task.WaitAll(
                namespaceManager.DeleteQueueAsync(targetQueue.Path),
                namespaceManager.DeleteQueueAsync(forwardingQueue.Path),
                namespaceManager.DeleteTopicAsync(topic.Path));
        }

 async Task<IEnumerable<QueueDescription>> SetupSagaTopologyAsync(NamespaceManager nm)
 {
     Console.WriteLine("Setup");
     return new List<QueueDescription>
     {
         await nm.QueueExistsAsync(SagaResultQueueName)
             ? await nm.GetQueueAsync(SagaResultQueueName)
             : await nm.CreateQueueAsync(SagaResultQueueName),
         await nm.QueueExistsAsync(CancelFlightQueueName)
             ? await nm.GetQueueAsync(CancelFlightQueueName)
             : await nm.CreateQueueAsync(new QueueDescription(CancelFlightQueueName)),
         await nm.QueueExistsAsync(BookFlightQueueName)
             ? await nm.GetQueueAsync(BookFlightQueueName)
             : await nm.CreateQueueAsync(
                 new QueueDescription(BookFlightQueueName)
                 {
                     // on failure, we move deadletter messages off to the flight 
                     // booking compensator's queue
                     EnableDeadLetteringOnMessageExpiration = true,
                     ForwardDeadLetteredMessagesTo = CancelFlightQueueName
                 }),
         await nm.QueueExistsAsync(CancelHotelQueueName)
             ? await nm.GetQueueAsync(CancelHotelQueueName)
             : await nm.CreateQueueAsync(new QueueDescription(CancelHotelQueueName)),
         await nm.QueueExistsAsync(BookHotelQueueName)
             ? await nm.GetQueueAsync(BookHotelQueueName)
             : await nm.CreateQueueAsync(
                 new QueueDescription(BookHotelQueueName)
                 {
                     // on failure, we move deadletter messages off to the hotel 
                     // booking compensator's queue
                     EnableDeadLetteringOnMessageExpiration = true,
                     ForwardDeadLetteredMessagesTo = CancelHotelQueueName
                 }),
         await nm.QueueExistsAsync(CancelRentalCarQueueName)
             ? await nm.GetQueueAsync(CancelRentalCarQueueName)
             : await nm.CreateQueueAsync(new QueueDescription(CancelRentalCarQueueName)),
         await nm.QueueExistsAsync(BookRentalCarQueueName)
             ? await nm.GetQueueAsync(BookRentalCarQueueName)
             : await nm.CreateQueueAsync(
                 new QueueDescription(BookRentalCarQueueName)
                 {
                     // on failure, we move deadletter messages off to the car rental 
                     // compensator's queue
                     EnableDeadLetteringOnMessageExpiration = true,
                     ForwardDeadLetteredMessagesTo = CancelRentalCarQueueName
                 }),
         await nm.QueueExistsAsync(SagaInputQueueName)
             ? await nm.GetQueueAsync(SagaInputQueueName)
             : await nm.CreateQueueAsync(
                 new QueueDescription(SagaInputQueueName)
                 {
                     // book car is the first step
                     ForwardTo = BookRentalCarQueueName
                 })
     };
 }