C# NamespaceManager.CreateQueueAsync方法代码示例

        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 static async Task SendAndCreateQueueIfNotExistsAsync(this MessageSender sender, BrokeredMessage message,
            Guid functionInstanceId, NamespaceManager namespaceManager, AccessRights accessRights, CancellationToken cancellationToken)
        {
            if (sender == null)
            {
                throw new ArgumentNullException("sender");
            }
            else if (namespaceManager == null)
            {
                throw new ArgumentNullException("namespaceManager");
            }

            ServiceBusCausalityHelper.EncodePayload(functionInstanceId, message);

            bool threwMessgingEntityNotFoundException = false;
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                await sender.SendAsync(message);
                return;
            }
            catch (MessagingEntityNotFoundException)
            {
                if (accessRights != AccessRights.Manage)
                {
                    // if we don't have the required rights to create the queue,
                    // rethrow the exception
                    throw;
                }

                threwMessgingEntityNotFoundException = true;
            }

            Debug.Assert(threwMessgingEntityNotFoundException);
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                await namespaceManager.CreateQueueAsync(sender.Path);
            }
            catch (MessagingEntityAlreadyExistsException)
            {
            }

            // Clone the message because it was already consumed before (when trying to send)
            // otherwise, you get an exception
            message = message.Clone();
            cancellationToken.ThrowIfCancellationRequested();
            await sender.SendAsync(message);
        }

        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));
        }

        public async Task SetupAsync(Type[] allMessageTypes, Type[] recievingMessageTypes)
        {
            _logger.Debug("Starting the setup of AzureServicebusTransport...");

            _namespaceManager = NamespaceManager.CreateFromConnectionString(_configuration.GetConnectionString());
            _messagingFactory = MessagingFactory.CreateFromConnectionString(_configuration.GetConnectionString());

            _messageTypes = allMessageTypes;

            var sendCommandTypes = _messageTypes
                .Where(t => typeof (IBusCommand)
                    .IsAssignableFrom(t));

            var sendEventTypes = _messageTypes
                .Where(t => typeof(IBusEvent)
                    .IsAssignableFrom(t));

            var recieveCommandTypes = recievingMessageTypes
                .Where(t => typeof(IBusCommand)
                    .IsAssignableFrom(t));

            var recieveEventTypes = recievingMessageTypes
                .Where(t => typeof(IBusEvent)
                    .IsAssignableFrom(t));

            if (_configuration.GetEnableTopicAndQueueCreation())
            {
                foreach (var type in sendCommandTypes)
                {
                    var path = PathFactory.QueuePathFor(type);
                    if (!_namespaceManager.QueueExists(path))
                        await _namespaceManager.CreateQueueAsync(path);

                    var client = _messagingFactory.CreateQueueClient(path);
                    client.PrefetchCount = 10; //todo;: in config?

                    var eventDrivenMessagingOptions = new OnMessageOptions
                    {
                        AutoComplete = true, //todo: in config?
                        MaxConcurrentCalls = 10 //todo: in config?
                    };
                    eventDrivenMessagingOptions.ExceptionReceived += OnExceptionReceived;
                    client.OnMessageAsync(OnMessageRecieved, eventDrivenMessagingOptions);

                    if (!_queues.TryAdd(type, client))
                    {
                        _logger.Error("Could not add the queue with type: {0}", type.FullName);
                    }
                }
                foreach (var type in sendEventTypes)
                {
                    var path = PathFactory.TopicPathFor(type);
                    if (!_namespaceManager.TopicExists(path))
                        _namespaceManager.CreateTopic(path);

                    var client = _messagingFactory.CreateTopicClient(path);

                    if (!_topics.TryAdd(type, client))
                    {
                        _logger.Error("Could not add the topic with type: {0}", type.FullName);
                    }


                }
            }

            _logger.Debug("Setup of AzureServicebusTransport completed!");

            throw new NotImplementedException();
        }

 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
                 })
     };
 }