C# MessagingFactory.CreateQueueClient方法代码示例

        public override bool OnStart()
        {
            //Setting up service bus
            var credentials = TokenProvider.CreateSharedSecretTokenProvider(_issuerName, _issuerKey);

            _factory =
                MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", _serviceNamespace, string.Empty), credentials);

            //Input queue client and error queue client creation
            _inputQueueClient = _factory.CreateQueueClient(_inputQueue);
            _errorQueueClient = _factory.CreateQueueClient(_errorQueue);

            return base.OnStart();
        }

        public DurableSender(MessagingFactory messagingFactory, string serviceBusQueueName)
        {
            // Create a Service Bus queue client to send messages to the Service Bus queue.
            this.queueClient = messagingFactory.CreateQueueClient(serviceBusQueueName);

            // Create MSMQ queue if it doesn't exit. If it does, open the existing MSMQ queue.
            this.msmqQueue = MsmqHelper.GetMsmqQueue(MsmqHelper.CreateMsmqQueueName(messagingFactory.Address.DnsSafeHost, serviceBusQueueName, "SEND"));

            // Create MSMQ deadletter queue if it doesn't exit. If it does, open the existing MSMQ deadletter queue.
            this.msmqDeadletterQueue = MsmqHelper.GetMsmqQueue(MsmqHelper.CreateMsmqQueueName(messagingFactory.Address.DnsSafeHost, serviceBusQueueName, "SEND_DEADLETTER"));

            // Start receiving messages from the MSMQ queue.
            this.MsmqPeekBegin();
        }

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

 public QueueClient Create(string description, MessagingFactory factory)
 {
     var client = factory.CreateQueueClient(description, ShouldRetry() ? ReceiveMode.PeekLock : ReceiveMode.ReceiveAndDelete);
     client.PrefetchCount = BatchSize;
     return client;
 }

 static QueueClient CreateQueueClient(Uri serviceUri, TokenProvider credentials, out MessagingFactory factory)
 {
     factory = MessagingFactory.Create(serviceUri, credentials);
     return factory.CreateQueueClient(QueueName);
 }

        static void Setup()
        {
            Console.WriteLine("Reading configuration...");

            _serviceNamespace = ConfigurationManager.AppSettings["ServiceBusNamespace"];
            Console.WriteLine(string.Format("* Service bus namespace is \"{0}\"", _serviceNamespace));

            _issuerName = ConfigurationManager.AppSettings["Issuer"];
            Console.WriteLine(string.Format("* Issuer \"{0}\"", _issuerName));

            _issuerKey = ConfigurationManager.AppSettings["Key"];
            Console.WriteLine(string.Format("* Key \"{0}\"", _issuerKey));

            _inputQueue = ConfigurationManager.AppSettings["InputQueueIdentifier"];
            Console.WriteLine(string.Format("* Input queue identifier \"{0}\" \r\n", _inputQueue));

            //Create queue client for posting to the input queue
            var credentials = TokenProvider.CreateSharedSecretTokenProvider(_issuerName, _issuerKey);
            _factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", _serviceNamespace, string.Empty), credentials);
            _inputQueueClient = _factory.CreateQueueClient(_inputQueue);
        }