C# IModel.ExchangeDeclare方法代码示例

        public RabbitMqConsumer(Uri uri, string exchange, IEnumerable<string> routingKeys)
        {
            var connectionFactory = new ConnectionFactory
                {
                    Uri = uri.ToString(),
                };
            _connection = connectionFactory.CreateConnection();
            _model = _connection.CreateModel();

            _model.ExchangeDeclare(exchange, ExchangeType.Topic, false);

            var queueName = string.Format("test-{0}", Guid.NewGuid());
            _model.QueueDeclare(
                queueName,
                false,
                false,
                true,
                null);

            foreach (var routingKey in routingKeys)
            {
                _model.QueueBind(
                    queueName,
                    exchange,
                    routingKey,
                    null);
            }

            _eventingBasicConsumer = new EventingBasicConsumer(_model);
            _eventingBasicConsumer.Received += OnReceived;

            _model.BasicConsume(queueName, false, _eventingBasicConsumer);
        }

        public Consumer(string queueName, IDictionary<string, string> headers, bool matchAll = true)
        {
            var factory = new ConnectionFactory {HostName = "localhost"};
            _connection = factory.CreateConnection();
            _channel = _connection.CreateModel();

            var args = new Dictionary<String, Object>();
            if (headers != null)
            {
                args.Add("x-match", matchAll ? "all" : "any");

                foreach (var item in headers)
                {
                    args.Add(item.Key, item.Value);
                }
            }

            _channel.ExchangeDeclare(ExchangeName, "headers", true);
            _channel.QueueDeclare(queueName, true, false, false, args);
            _channel.QueueBind(queueName, ExchangeName, string.Empty);

            const bool nonTransactional = true;
            _consumer = new EventingBasicConsumer();
            _consumer.Received += ConsumerReceived;
            _channel.BasicConsume(queueName, nonTransactional, _consumer);
        }

        protected BaseConsumer(string hostName, string exchangeName, string user, string pass, params string[] bindingKeys)
        {
            this.exchangeName = exchangeName;
            this.hostName = hostName;

            var connectionFactory = new ConnectionFactory()
            {
                HostName = hostName,
                UserName = user,
                Password = pass
            };

            connection = connectionFactory.CreateConnection();
            model = connection.CreateModel();
            //model.BasicQos(0, 1, false);

            model.ExchangeDeclare(exchangeName, "topic");

            queue = DeclareQueue(Queue);

            foreach (var key in bindingKeys)
            {
                model.QueueBind(queue, exchangeName, key);
            }
        }

 private static void CreateConnection()
 {
     _factory = new ConnectionFactory { HostName = "localhost", UserName = "guest", Password = "guest" };
     _connection = _factory.CreateConnection();
     _model = _connection.CreateModel();
     _model.ExchangeDeclare(ExchangeName, "fanout", false);
 }

        private void Connect()
        {
            var cf = new ConnectionFactory();
            _connection = cf.CreateConnection();
            _channel = _connection.CreateModel();
            _channel.ExchangeDeclare(_configurationService.WorkersExchange, ExchangeType.Direct);

            // Listen for heartbeats
            _channel.QueueDeclare(_configurationService.WorkerPingQueue, false, false, true, null);
            _channel.QueueBind(_configurationService.WorkerPingQueue, _configurationService.WorkersExchange, _configurationService.WorkerPingQueue);
            var heartbeatConsumer = new EventingBasicConsumer(_channel);
            heartbeatConsumer.Received += OnReceivedHeartbeat;
            heartbeatConsumer.ConsumerCancelled += OnConsumerCancelled;
            heartbeatConsumer.Shutdown += OnShutdown;
            _channel.BasicConsume(_configurationService.WorkerPingQueue, true, heartbeatConsumer);

            // Listen or status changes
            _channel.QueueDeclare(_configurationService.WorkerStatusQueue, false, false, true, null);
            _channel.QueueBind(_configurationService.WorkerStatusQueue, _configurationService.WorkersExchange, _configurationService.WorkerStatusQueue);
            var statusConsumer = new EventingBasicConsumer(_channel);
            statusConsumer.Received += OnReceivedStatus;
            statusConsumer.ConsumerCancelled += OnConsumerCancelled;
            statusConsumer.Shutdown += OnShutdown;
            _channel.BasicConsume(_configurationService.WorkerStatusQueue, false, statusConsumer);
        }

        private static void SetupInitialTopicQueue(IModel model)
        {
            model.QueueDeclare("queueFromVisualStudio", true, false, false, null);

            model.ExchangeDeclare("exchangeFromVisualStudio", ExchangeType.Topic, true);
            model.QueueBind("queueFromVisualStudio", "exchangeFromVisualStudio", "superstars");
        }

        public IModel Connect(AmqpSettings settings)
        {
            var factory = new ConnectionFactory
            {
                UserName = settings.user
                ,
                Password = settings.password
                ,
                HostName = settings.hostName
                ,
                AutomaticRecoveryEnabled = true
                ,
                NetworkRecoveryInterval = TimeSpan.FromSeconds(10);
            };

            _connect = factory.CreateConnection();

            _channel = _connect.CreateModel();

            _channel.ExchangeDeclare(settings.exchangeName, ExchangeType.Direct);
            _channel.QueueDeclare(settings.queueName, false, false, false, null);
            _channel.QueueBind(settings.queueName, settings.exchangeName, settings.routingKey, null);

            return _channel;
        }

        private void EstablishConnection()
        {
            try
            {
                if (connection != null)
                {
                    if (connection.IsOpen)
                        return;
                    throw new CannotConnectException(string.Format("Cannot connect to {0}", configuration.ConnectionUri));
                }

                var connectionFactory = new ConnectionFactory
                    {
                        Uri = configuration.ConnectionUri,
                        AutomaticRecoveryEnabled = true,
                        TopologyRecoveryEnabled = true,
                        UseBackgroundThreadsForIO = true,
                        RequestedHeartbeat = 10,
                    };
                connection = connectionFactory.CreateConnection();
                channel = connection.CreateModel();
                channel.ExchangeDeclare(configuration.Exchange, configuration.ExchangeType, true);
                channel.QueueDeclare(configuration.Queue, true, false, false, new Dictionary<string, object>());
                channel.QueueBind(configuration.Queue, configuration.Exchange, configuration.RoutingKey);
            }
            catch (Exception exception)
            {
                channel.SafeDispose();
                channel = null;
                connection.SafeDispose();
                connection = null;
                throw new CannotConnectException(string.Format("Cannot connect to {0}", configuration.ConnectionUri), exception);
            }
        }

        public override void StartListening()
        {
            _rabbitConnection = _configuration.RabbitMqClusterMembers?.Count > 0
                ? _configuration.ConnectionFactory.CreateConnection(_configuration.RabbitMqClusterMembers)
                : _configuration.ConnectionFactory.CreateConnection();
            _publishModel = _rabbitConnection.CreateModel();
            _receiveModel = _rabbitConnection.CreateModel();
            _receiveModel.ExchangeDeclare(_configuration.ExchangeName, ExchangeType.Fanout, true);
            var queue = _configuration.QueueName == null
                ? _receiveModel.QueueDeclare()
                : _receiveModel.QueueDeclare(_configuration.QueueName, true, false, false,
                    new Dictionary<string, object>());
            _receiveModel.QueueBind(queue.QueueName, _configuration.ExchangeName, "");

            var consumer = new EventingBasicConsumer(_receiveModel);
            consumer.Received += (sender, args) =>
            {
                var message = new RabbitMqMessageWrapper
                {
                    Bytes = args.Body,
                    Id =
                        Convert.ToUInt64(Encoding.UTF8.GetString((byte[]) args.BasicProperties.Headers[MessageIdHeader]))
                };
                OnMessage(message);
            };

            _receiveModel.BasicConsume(queue.QueueName, true, consumer);
        }

        public RabbitMQPublisher(string connection)
        {
            factory = new ConnectionFactory();

            if (connection != null && connection != string.Empty)
            {
                factory.Uri = connection;
            }
            else
            {
                factory.HostName = "localhost";
            }

            Console.WriteLine("Creating connection...");
            factory.Protocol = Protocols.FromEnvironment();

            conn = factory.CreateConnection();

            Console.WriteLine("Creating channel...");
            model = conn.CreateModel();

            Console.WriteLine("Creating exchange...");
            model.ExchangeDeclare("exch", ExchangeType.Direct);

            Console.WriteLine("Creating queue...");
            model.QueueDeclare("queue", true, false, true, null);

            model.QueueBind("queue", "exch", "key", new Dictionary<string, object>());
        }

        public override void StartListening()
        {
            _rabbitConnection = Configuration.ConnectionFactory.CreateConnection();

            _publishModel = _rabbitConnection.CreateModel();
            _subscribeModel = _rabbitConnection.CreateModel();

            _publishModel.ExchangeDeclare(Configuration.StampExchangeName, "x-stamp", durable: true);
            _subscribeModel.ExchangeDeclare(Configuration.ExchangeName, ExchangeType.Fanout, durable: true);
            _subscribeModel.QueueDeclare(Configuration.QueueName, durable: false, exclusive: false, autoDelete: true, arguments: new Dictionary<string, object>());
            _subscribeModel.QueueBind(Configuration.QueueName, Configuration.ExchangeName, "");

            var consumer = new EventingBasicConsumer(_subscribeModel);
            consumer.Received += (sender, args) =>
            {
                try
                {
                    OnMessage(new RabbitMqMessageWrapper
                    {
                        Bytes = args.Body,
                        Id = Convert.ToUInt64(args.BasicProperties.Headers["stamp"])
                    });
                }
                finally
                {
                    _subscribeModel.BasicAck(args.DeliveryTag, multiple: false);
                }
            };

            _subscribeModel.BasicConsume(Configuration.QueueName, noAck: false, consumer: consumer);
        }

 private void OpenConnection()
 {
     connection = CreateConnectionFactory().CreateConnection();
     connection.ConnectionShutdown += ConnectionShutdown;
     model = connection.CreateModel();
     model.ExchangeDeclare(Exchange, ExchangeType, Durable);
 }

        public Publisher()
        {
            var factory = new ConnectionFactory { HostName = "localhost" };

            _connection = factory.CreateConnection();
            _channel = _connection.CreateModel();
            _channel.ExchangeDeclare(ExchangeName, "direct", true);
        }

 private static string DeclareAndBindQueueToExchange(IModel channel)
 {
     channel.ExchangeDeclare(ExchangeName, "fanout");
     var queueName = channel.QueueDeclare().QueueName;
     channel.QueueBind(queueName, ExchangeName, "");
     _consumer = new QueueingBasicConsumer(channel);
     return queueName;
 }

		protected virtual void DeclareSystemExchange(IModel channel, PublicationAddress address)
		{
			if (this.DispatchOnly || address == null)
				return;

			channel.ExchangeDeclare(address.ExchangeName, address.ExchangeType, true, false, null);
			channel.QueueDeclare(address.ExchangeName, true, false, false, null);
			channel.QueueBind(address.ExchangeName, address.ExchangeName, address.RoutingKey, null);
		}