static void Main(string[] args)
        {
            var factory = GetConnectionFactory();
              using (var connection = factory.CreateConnection())
              {
            using (var channel = connection.CreateModel())
            {
              DeclareExchange(channel);
              DeclareQ(channel, Constants.MASTER_CUSTOMER_QUEUE_NAME);
              SetUpQoS(channel);

              BindToQ(channel, Constants.MASTER_CUSTOMER_QUEUE_NAME, Constants.NEW_CUSTOMER_EVENT);

              Console.WriteLine(" [CRM] Waiting for messages.");

              var consumer = new EventingBasicConsumer(channel);
              consumer.Received += (Model, ea) =>
              {
            var body = ea.Body;
            var message = Encoding.UTF8.GetString(body);
            var routingKey = ea.RoutingKey;

            Console.WriteLine(" [>>>>>>>>>>] Received MESSAGE '{0}'", routingKey);

            ProcessMessage(channel, message, routingKey);
            channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
              };
              channel.BasicConsume(queue: Constants.MASTER_CUSTOMER_QUEUE_NAME, noAck: false, consumer: consumer);

              Console.WriteLine(" Press [enter] to exit.");
              Console.ReadLine();
            }
              }
        }
        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);
        }
Beispiel #3
0
        public RpcClient()
        {
            var factory = new ConnectionFactory()
            {
                HostName = "localhost"
            };

            connection     = factory.CreateConnection();
            channel        = connection.CreateModel();
            replyQueueName = channel.QueueDeclare().QueueName;
            consumer       = new EventingBasicConsumer(channel);

            props = channel.CreateBasicProperties();
            var correlationId = Guid.NewGuid().ToString();

            props.CorrelationId = correlationId;
            props.ReplyTo       = replyQueueName;

            consumer.Received += (model, ea) =>
            {
                var body     = ea.Body;
                var response = Encoding.UTF8.GetString(body);
                if (ea.BasicProperties.CorrelationId == correlationId)
                {
                    respQueue.Add(response);
                }
            };
        }
Beispiel #4
0
        private static void Main(string[] args)
        {
            var factory = new ConnectionFactory() { Uri = "amqp://*****:*****@black-boar.rmq.cloudamqp.com/nopqbtng" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.ExchangeDeclare(exchange: "OnAMission", type: "fanout");

                var queueName = channel.QueueDeclare().QueueName;
                channel.QueueBind(queue: queueName,
                                  exchange: "OnAMission",
                                  routingKey: "");

                Console.WriteLine(" [*] Waiting for logs.");

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" [x] {0}", message);
                };
                channel.BasicConsume(queue: queueName,
                                     noAck: true,
                                     consumer: consumer);

                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.QueueDeclare(queue: "task_queue", durable: true, exclusive: false, autoDelete: false, arguments: null);

            channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

            Console.WriteLine(" [*] Waiting for messages.");

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine(" [x] Received {0}", message);

                int dots = message.Split('.').Length - 1;
                Thread.Sleep(dots * 1000);

                Console.WriteLine(" [x] Done");

                channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
            };
            channel.BasicConsume(queue: "task_queue", noAck: false, consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
        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 void TestEventingConsumerRegistrationEvents()
        {
            string q = Model.QueueDeclare();

            var registeredLatch = new ManualResetEvent(false);
            object registeredSender = null;
            var unregisteredLatch = new ManualResetEvent(false);
            object unregisteredSender = null;

            EventingBasicConsumer ec = new EventingBasicConsumer(Model);
            ec.Registered += (s, args) =>
            {
                registeredSender = s;
                registeredLatch.Set();
            };

            ec.Unregistered += (s, args) =>
            {
                unregisteredSender = s;
                unregisteredLatch.Set();
            };

            string tag = Model.BasicConsume(q, false, ec);
            Wait(registeredLatch);

            Assert.IsNotNull(registeredSender);
            Assert.AreEqual(ec, registeredSender);
            Assert.AreEqual(Model, ((EventingBasicConsumer)registeredSender).Model);

            Model.BasicCancel(tag);
            Wait(unregisteredLatch);
            Assert.IsNotNull(unregisteredSender);
            Assert.AreEqual(ec, unregisteredSender);
            Assert.AreEqual(Model, ((EventingBasicConsumer)unregisteredSender).Model);
        }
        public static void HandleQueueItems()
        {
            var factory = new ConnectionFactory { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.QueueDeclare(queue: "VehicleQueue",
                                     durable: false,
                                     exclusive: false,
                                     autoDelete: false,
                                     arguments: null);

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" [x] Received {0}", message);
                    PluginManager.HandleMessageForLoadedPlugins(new ExampleMessage { BodyText = message });
                };
                channel.BasicConsume(queue: "VehicleQueue",
                                     noAck: true,
                                     consumer: consumer);
                Thread.Sleep(new TimeSpan(0, 0, 10));
            }
        }
Beispiel #9
0
        public static void Receive2()
        {
            var factory = new RabbitMQ.Client.ConnectionFactory()
            {
                HostName = "localhost"
            };

            using (var connection = factory.CreateConnection())
            {
                using (var channel = connection.CreateModel())
                {
                    var queueDeclare = channel.QueueDeclare("task_queue", true, false, false, null);

                    //用于平衡调度,指定在接收端为处理完成之前不分配其他消息给该接收端
                    //如果不设置,假如有100条待处理记录,有两个接收端处理,无论两个接收端处理速度快慢,都同等分配50条
                    //如果设置该平衡调度,处理速度快的客户端会多分配
                    channel.BasicQos(0, 1, false);

                    var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                    consumer.Received += (model, ea) =>
                    {
                        var body    = ea.Body;
                        var message = Encoding.UTF8.GetString(body);
                        Console.WriteLine(" [x] Received {0}", message);
                        channel.BasicAck(ea.DeliveryTag, false);

                        var i = Convert.ToInt32(message.Substring(message.Length - 1, 1));
                        System.Threading.Thread.Sleep((i % 2 == 1 ? 5 : 1) * 1000);
                    };
                    channel.BasicConsume(queue: queueDeclare.QueueName, noAck: false, consumer: consumer);
                    Console.WriteLine("consumer启动成功,Press [enter] to exit.");
                    Console.ReadLine(); //注意不要跳出,或者会释放资源,无法自动同步
                }
            }
        }
Beispiel #10
0
        public static void Main()
        {
            var factory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {// tutaj tez deklarujemy kolejke, ze wzgledu na to, iż możemy rozpoczac odbnieranie nim wysłannik wyśle wiadomość
                //chcemy miec pewnośc, że kolejka istnieje 
                channel.QueueDeclare(queue: "hello",
                                     durable: false,
                                     exclusive: false,
                                     autoDelete: false,
                                     arguments: null);
                //mowimy serwerowi by dostarczył nam wiadomośc z kolejki

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                    {
                        var body = ea.Body;
                        var message = Encoding.UTF8.GetString(body);
                        Console.WriteLine(" [x] Received {0}", message);
                    };
                channel.BasicConsume(queue: "hello",
                                     noAck: true,
                                     consumer: consumer);

                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }
Beispiel #11
0
        public static void Run()
        {
            var factory = new ConnectionFactory() { HostName = "localhost" };
            using(var connection = factory.CreateConnection())
            using(var channel = connection.CreateModel())
            {
                channel.ExchangeDeclare(exchange: "logs", type: "fanout");

                var queueName = channel.QueueDeclare().QueueName;
                channel.QueueBind(queue: queueName, exchange: "logs", routingKey: "");

                Console.WriteLine(" [*] Waiting for logs.");
            
                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" [x] {0}", message);
                };
                string basicConsume = channel.BasicConsume(queue: queueName, noAck: false, consumer: consumer);
                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }
Beispiel #12
0
        public static void Receive1()
        {
            var factory = new RabbitMQ.Client.ConnectionFactory()
            {
                HostName = "localhost"
            };

            using (var connection = factory.CreateConnection())
            {
                using (var channel = connection.CreateModel())
                {
                    var queueDeclare = channel.QueueDeclare("hello", false, false, false, null);

                    //平衡调度,在Receiver处理并确认前一个消息之前,不会分发新的消息给Receiver
                    channel.BasicQos(0, 1, false);

                    var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                    consumer.Received += (sender, ea) =>
                    {
                        var message = Encoding.UTF8.GetString(ea.Body);
                        Console.WriteLine("[x] Received {0}", message);
                        channel.BasicAck(ea.DeliveryTag, false);
                    };
                    channel.BasicConsume(queueDeclare.QueueName, false, consumer);
                    Console.WriteLine("consumer启动成功,Press [enter] to exit.");
                    Console.ReadLine(); //注意不要跳出,或者会释放资源,无法自动同步
                }
            }
        }
Beispiel #13
0
    public void Worker()
    {
        Text log = GameObject.Find("console").GetComponent<Text>();
           	  var factory = new ConnectionFactory() { HostName = "diablo", UserName = "******" ,Password = "******"};
        using(var connection = factory.CreateConnection())
        using(var channel = connection.CreateModel())
        {
            channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                //var body = ea.Body;
                //var message = Encoding.UTF8.GetString(body);
                //Console.WriteLine(" [x] Received {0}", message);

               /// int dots = message.Split('.').Length - 1;
                //
                Thread.Sleep(1000);
                log.text = log.text + "[ "+ DateTime.Now.ToString("HH:mm:ss") +" ] recebendo mensagens. \n";

                channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);

            };
            channel.BasicConsume(queue: "Work_Queue",
                                 noAck: false,
                                 consumer: consumer);
        }
    }
Beispiel #14
0
        static void Main(string[] args)
        {
            var factory = new ConnectionFactory { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            {
                using (var channel = connection.CreateModel())
                {
                    // Declare the exchange
                    channel.ExchangeDeclare(exchange: "direct_logs", type: ExchangeType.Direct);

                    // Declare anonymous/temporary queue
                    var queueName = channel.QueueDeclare().QueueName;
                    var routingKey = args[0];

                    // Bind to the exchange
                    channel.QueueBind(queue: queueName, exchange: "direct_logs", routingKey: routingKey);

                    Console.WriteLine("[*] Waiting for logs...");

                    var consumer = new EventingBasicConsumer(channel);
                    consumer.Received += (model, dlvrArgs) =>
                    {
                        var body = dlvrArgs.Body;
                        var routingKey1 = dlvrArgs.RoutingKey;
                        var message = Encoding.UTF8.GetString(body);
                        Console.WriteLine(" [x] Received {0} : {1}", routingKey1, message);
                    };

                    channel.BasicConsume(queue: queueName, noAck: true, consumer: consumer);
                    Console.ReadLine();
                }
            }
        }
        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);
        }
Beispiel #16
0
        private static void Main(string[] args)
        {
            Console.WriteLine("----------Sad Receiver----------");
            Console.WriteLine("Press [Enter] to exit.");

            var factory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.ExchangeDeclare(exchange: "Emotional_Messages",
                    type: "direct");
                var queueName = channel.QueueDeclare().QueueName;


                channel.QueueBind(queue: queueName,
                    exchange: "Emotional_Messages",
                    routingKey: "Sad");

                Console.WriteLine("Waiting for messages...");

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" Received {0}", message);
                };
                channel.BasicConsume(queue: queueName,
                    noAck: true,
                    consumer: consumer);

                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="RabbitMqEventConsumer"/> class.
        /// </summary>
        /// <param name="connectionFactory">The connection factory.</param>
        /// <param name="exchangePath">The exchange path.</param>
        /// <param name="queue">The queue.</param>
        public RabbitMqEventConsumer(ConnectionFactory connectionFactory, string exchangePath, string queue)
        {
            _active = 1;
            _connection = connectionFactory.CreateConnection();
            _model = _connection.CreateModel();
            _queue = _model.QueueDeclare(queue, true, false, false, new Hashtable());

            // bind the queue to an exchange if specified
            if (exchangePath != null)
            {
                _model.QueueBind(_queue, exchangePath, string.Empty);
            }

            EventingBasicConsumer eventingBasicConsumer = new EventingBasicConsumer();
            eventingBasicConsumer.Received += HandleEvent;

            _model.BasicConsume(_queue, true, eventingBasicConsumer);

            #if false
            _subscription = new Subscription(_model, _queue, true);
            var thread = new Thread(ReceiveEvents);
            thread.IsBackground = true;
            thread.Name = "rabbitmq:consumer";
            thread.Start();
            #endif

            var uriBuilder = new UriBuilder(
                "rabbitmq",
                connectionFactory.HostName,
                connectionFactory.Port,
                queue);

            Uri = uriBuilder.Uri;
        }
        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);
        }
        public Rabbit(string address)
        {
            cf = new ConnectionFactory();
            //cf.Port = 35672;
            cf.UserName = "******";
            cf.Password = "******";
            cf.Address = address;
            conn = cf.CreateConnection();
            IModel c = Connect();
            conn.AutoClose = false;
            UriSettings();

            _address = address.Substring(0, address.IndexOf(":"));

            ProcessQueues();

            System.Timers.Timer aTimer = new System.Timers.Timer();
            aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
            aTimer.Interval = 60 * 1000;
            aTimer.Enabled = true;

            var consumer = new EventingBasicConsumer();
            consumer.Received += (model, ea) =>
            {
                ProcessQueues();
                Console.WriteLine("Received event");
            };

            c.BasicConsume("task_queue", false, null, consumer);

            Console.ReadKey();
        }
        public void TestEventingConsumerRegistrationEvents()
        {
            string q = Model.QueueDeclare();

            bool registeredInvoked = false;
            object registeredSender = null;
            bool unregisteredInvoked = false;
            object unregisteredSender = null;

            EventingBasicConsumer ec = new EventingBasicConsumer(Model);
            ec.Registered += (s, args) =>
            {
                registeredInvoked = true;
                registeredSender = s;
            };

            ec.Unregistered += (s, args) =>
            {
                unregisteredInvoked = true;
                unregisteredSender = s;
            };

            string tag = Model.BasicConsume(q, false, ec);

            Assert.IsTrue(registeredInvoked);
            Assert.IsNotNull(registeredSender);
            Assert.AreEqual(ec, registeredSender);
            Assert.AreEqual(Model, ((EventingBasicConsumer)registeredSender).Model);

            Model.BasicCancel(tag);
            Assert.IsTrue(unregisteredInvoked);
            Assert.IsNotNull(unregisteredSender);
            Assert.AreEqual(ec, unregisteredSender);
            Assert.AreEqual(Model, ((EventingBasicConsumer)unregisteredSender).Model);
        }
Beispiel #21
0
        static void Main(string[] args)
        {
            var channel = _connection.CreateModel();

                channel.QueueDeclare("BanksList", true, false, false, null);

                var consumer = new EventingBasicConsumer();

                consumer.Model = channel;

                consumer.Received += (s, e) =>
                {

                    var message = e.Body.ToRequestMessage<BanksListMessage>();

                    foreach (var bankName in message.BanksList)
                    {

                        var bankChannelName = ConfigurationManager.AppSettings[bankName].ToString();

                        _channels[bankChannelName].BasicPublish("", bankChannelName, null, message.ToByteArray());
                    }

                };

                channel.BasicConsume("BanksList", true, consumer);
        }
        static void Main(string[] args)
        {
            var factory = GetConnectionFactory();
            using (var connection = factory.CreateConnection())
            {
                using (var channel = connection.CreateModel())
                {
                    DeclareExchange(channel);
                    DeclareQ(channel, Constants.LOGGING_QUEUE_NAME);
                    SetUpQoS(channel);
                    foreach (var eventName in Constants.EventCollection)
                    {
                        BindToQ(channel, Constants.LOGGING_QUEUE_NAME, eventName);
                    }

                    Console.WriteLine(" [LOGGER] Waiting for messages.");

                    var consumer = new EventingBasicConsumer(channel);
                    consumer.Received += (model, ea) =>
                    {
                        var body = ea.Body;
                        var message = Encoding.UTF8.GetString(body);
                        var routingKey = ea.RoutingKey;
                        LogMessage(routingKey, message);
                        Console.WriteLine(" [x] Received '{0}':'{1}'", routingKey, message);
                        //channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };
                    channel.BasicConsume(queue: Constants.LOGGING_QUEUE_NAME, noAck: true, consumer: consumer);

                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
Beispiel #23
0
        private static void Main(string[] args)
        {
            Console.WriteLine("----------Receiver (ALL HAPPY MESSAGES)----------");
            Console.WriteLine("Press [Enter] to exit.");

            var factory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.ExchangeDeclare(exchange: "topic_example", type: "topic");
                var queueName = channel.QueueDeclare().QueueName;

                channel.QueueBind(queue: queueName,
                                  exchange: "topic_example",
                                  routingKey: "Happy.*");

                Console.WriteLine("Waiting for messages...");

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    var routingKey = ea.RoutingKey;
                    Console.WriteLine(" Received '{0}':'{1}'",
                                      routingKey,
                                      message);
                };
                channel.BasicConsume(queue: queueName,
                                     noAck: true,
                                     consumer: consumer);

                Console.ReadLine();
            }
        }
        public static void Main()
        {
            var factory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.ExchangeDeclare(ExchangeName, ExchangeType);

                //non-durable, exclusive, autodelete queue with a generated name
                var anonymousQueueName = channel.QueueDeclare().QueueName;
                Console.WriteLine("anonymousQueueName is:" + anonymousQueueName);
                //Create a binding - makes the exchange filter to the queue
                channel.QueueBind(anonymousQueueName, ExchangeName, EmptyRoutingKey);

                Console.WriteLine(" [*] Waiting for logs.");

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" [x] {0}", message);
                };
                channel.BasicConsume(anonymousQueueName, true, consumer);

                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }
 public void Subscribe(string queueName, EventHandler<BasicDeliverEventArgs> handler)
 {
     CreateQueue(queueName);
     var consumer = new EventingBasicConsumer(_model);
     consumer.Received += handler;
     _model.BasicConsume(queueName, true, consumer);
 }
Beispiel #26
0
        private static void HelloWorld()
        {
            var connectionFactory = new ConnectionFactory
            {
                HostName = "localhost"
            };
            using (var connection = connectionFactory.CreateConnection())
            {
                using (IModel channel = connection.CreateModel())
                {
                    channel.QueueDeclare(queue: "hello",
                        durable: false,
                        exclusive: false,
                        autoDelete: false,
                        arguments: null);
                    var consumer = new EventingBasicConsumer(channel);
                    consumer.Received += (sender, eventArgs) =>
                    {
                        string body = Encoding.UTF8.GetString(eventArgs.Body);
                        Console.WriteLine(" [x] Received {0}", body);
                    };

                    channel.BasicConsume("hello", true, consumer);


                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
        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);
        }
Beispiel #28
0
        protected virtual void OnTick(object sender, ElapsedEventArgs e)
        {
            var connectionFactory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = connectionFactory.CreateConnection())
            {
                using (var channel = connection.CreateModel())
                {
                    channel.ExchangeDeclare("TestWindowsExchange", "fanout");
                    channel.QueueDeclare("TestWindowsQueue", true, false, false, null);
                    channel.QueueBind("TestWindowsQueue", "TestWindowsExchange", "");
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
                    Console.WriteLine(" [*] Waiting for messages");

                    var consumer = new EventingBasicConsumer(channel);
                    consumer.Received += (model, ea) =>
                    {
                        var body = ea.Body;
                        var message = Encoding.UTF8.GetString(body);
                        Console.WriteLine(" [x] Received {0}", message);

                        CallSubscriberApi(message);

                        Console.WriteLine(" [x] Done");


                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };

                    channel.BasicConsume(queue: "TestWindowsQueue", noAck: false, consumer: consumer);
                    Console.WriteLine("Press Enter to exit");
                    Console.ReadLine();
                }

            }
        }
        private static void ReceiveMessages()
        {
            var factory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.QueueDeclare(queue: "Hello Queue",
                                     durable: false,
                                     exclusive: false,
                                     autoDelete: false,
                                     arguments: null);

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" [x] Received {0}", message);
                };
                channel.BasicConsume(queue: "Hello Queue",
                                     noAck: true,
                                     consumer: consumer);

                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }
Beispiel #30
0
    public void receivePSMessage()
    {
        Debug.Log("Start");
        Text log = GameObject.Find("console").GetComponent<Text>();
        log.text = log.text + "[ "+ DateTime.Now.ToString("HH:mm:ss") +" ] Aguardando mensagens.\n";
        var factory = new ConnectionFactory() { HostName = "diablo", UserName = "******", Password = "******"  };
        using(var connection = factory.CreateConnection())
            using(var channel = connection.CreateModel())
        {
            if(uuid == ""){
                setUuid("amq-" + Guid.NewGuid().ToString());
            }
            channel.ExchangeDeclare(exchange: "publishSubEX", type: "fanout");
            var queueName = channel.QueueDeclare(uuid, false,false,false,null);
            channel.QueueBind(queueName,"publishSubEX","");

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                Utils.SaveFileToDisk("rabbit.png",body);
                var fileInfo = new System.IO.FileInfo("rabbit.png");
                var fileSize = (fileInfo.Length/1024f)/1024f;
                log.text = log.text = log.text + "[ "+ DateTime.Now.ToString("HH:mm:ss") +" ] Mensagem Enviada Publish / Subscribe : " + fileSize.ToString("0.00") + " MB" + "\n";
            };
            channel.BasicConsume(queue: queueName,
                                 noAck: true,
                                 consumer: consumer);
        }
    }
        public RabbitMQReceiver(IConnection connection, string queueName)
        {
            Connection = connection;
            QueueName = queueName;
            MessageStringProperties = null;

            consumer = new EventingBasicConsumer();
            IsStarted = false;
        }
        // Usando filtrando por error:
        // RabbitMQ.Consumer.exe error
        private static void ConsumoEnvioComExchange_Direct(string[] args)
        {
            // Instalando RabbitMQ no projeto
            // Install-Package RabbitMQ.Client

            // Host a se conectar
            var factory = new ConnectionFactory() { HostName = "localhost" };

            // Cria uma conexão específica para o endpoint
            using (var connection = factory.CreateConnection()) {
                // Abre um canal e cria a fila
                using (var channel = connection.CreateModel()) {
                    channel.ExchangeDeclare(exchange: "direct_logs", type: "direct");

                    // Quando criamos uma fila sem parâmentros usando QueueDeclare()
                    // É criada uma fila não durável, exclusiva e autoDelete com um nome gerado automáticamente
                    // Ex:
                    // amq.gen-JzTY20BRgKO-HjmUJj0wLg
                    var queueName = channel.QueueDeclare().QueueName;

                    if (args.Length < 1) {
                        Console.Error.WriteLine("Usage: {0} [info] [warning] [error]",
                            Environment.GetCommandLineArgs()[0]);
                        Console.WriteLine("Press [enter] to exit.");
                        Console.ReadLine();
                        Environment.ExitCode = 1;
                        return;
                    }

                    foreach (var severity in args) {
                        channel.QueueBind(queue: queueName,
                            exchange: "direct_logs",
                            routingKey: severity);
                    }

                    Console.WriteLine("[*] Aguardando por mensagens..");

                    // Cria um consumer básico
                    var consumer = new EventingBasicConsumer(channel);

                    // Cria um evento que será disparado quando tiver algum item para ser recebidos
                    consumer.Received += (model, routingkey) => {
                        var body = routingkey.Body; // Pega a mensagem pela rota
                        var message = Encoding.UTF8.GetString(body); // Converte os bytes em string

                        Console.WriteLine("[x] Mensagem recebida: {0}", message);
                    };

                    channel.BasicConsume(queue: queueName,
                        noAck: true,
                        consumer: consumer);

                    Console.WriteLine("Press [enter] to exit.");
                    Console.ReadLine();
                }
            }
        }
Beispiel #33
0
        public static void Receive6()
        {
            var factory = new ConnectionFactory()
            {
                HostName = "localhost"
            };

            using (var connection = factory.CreateConnection())
                using (var channel = connection.CreateModel())
                {
                    channel.QueueDeclare(queue: "rpc_queue", durable: false, exclusive: false, autoDelete: false, arguments: null);
                    channel.BasicQos(0, 1, false);
                    var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                    channel.BasicConsume(queue: "rpc_queue", noAck: false, consumer: consumer);
                    Console.WriteLine(" [x] Awaiting RPC requests");

                    consumer.Received += (model, ea) =>
                    {
                        string response = null;

                        var body       = ea.Body;
                        var props      = ea.BasicProperties;
                        var replyProps = channel.CreateBasicProperties();
                        replyProps.CorrelationId = props.CorrelationId;

                        try
                        {
                            var message = Encoding.UTF8.GetString(body);
                            int n       = int.Parse(message);
                            Console.WriteLine(" [.] fib({0})", message);
                            response = "返回" + message;
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(" [.] " + e.Message);
                            response = "";
                        }
                        finally
                        {
                            var responseBytes = Encoding.UTF8.GetBytes(response);
                            channel.BasicPublish(exchange: "", routingKey: props.ReplyTo, basicProperties: replyProps, body: responseBytes);
                            channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                        }
                    };

                    Console.WriteLine(" Press [enter] to exit.");
                    Console.ReadLine();
                }
        }
Beispiel #34
0
        /// <summary>
        /// rabbitmq测试
        /// </summary>
        public static void RabbitTest()
        {
            Task t = new Task(() =>
            {
                var factory = new ConnectionFactory
                {
                    HostName    = "localhost",
                    UserName    = "******",
                    Password    = "******",
                    Port        = 5672,
                    VirtualHost = "/",
                    AutomaticRecoveryEnabled = true
                };
                //创建消息队列连接
                var connection = factory.CreateConnection();

                IModel channel = connection.CreateModel();
                //绑定交换机
                channel.ExchangeDeclare("lijie_Exchange", "direct", true, false);

                //申明消息队列
                channel.QueueDeclare("jietest0304", true, false, false);

                //绑定消息队列到交换机
                channel.QueueBind("jietest0304", "lijie_Exchange", "Key_jietest0304");
                //费者在接收到队列里的消息但没有返回确认结果之前,队列不会将新的消息分发给该消费者。队列中没有被消费的消息不会被删除,还是存在于队列中
                channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);

                EventingBasicConsumer consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                //消费事件
                consumer.Received += (p, q) =>
                {
                    ReadOnlyMemory <byte> body = q.Body;
                    var message = System.Text.Encoding.UTF8.GetString(body.ToArray());
                    Console.WriteLine($"消费:{message}");
                    //消息确认
                    channel.BasicAck(deliveryTag: q.DeliveryTag, multiple: false);
                };
                //启动消费
                channel.BasicConsume("jietest0304", autoAck: false, consumer: consumer);
            });

            t.Start();
            while (true)
            {
            }
        }
        /// <summary>
        /// //发消息对队列,通过Rpc事件驱动获取回复消息(推荐此方式)
        ///
        /// </summary>
        /// <param name="count"></param>
        private void InsertAndGetResponseMsgByEnevt(int count)
        {
            #region ConnectionFactory
            var factory = new ConnectionFactory();
            factory.HostName    = "192.168.1.69"; //RabbitMQ服务在本地运行
            factory.UserName    = "******";        //用户名
            factory.Password    = "******";     //密码
            factory.VirtualHost = "newbpo";
            #endregion

            /*
             * 发布消息,消息找队列,常用3种路由方式:
             * Direct:根据路由键进行,消息发送到该交换机且绑定有该路由键的队列;
             * Fanout:广播模式,忽略路由键,消息会发送到绑定在交换机上面的所有队列;
             * Topic:类似Direct,但是匹配路由键可以根据匹配符进行匹配队列;
             */
            using (var conn = factory.CreateConnection())   //创建连接
            {
                using (IModel channel = conn.CreateModel()) //创建对象
                {
                    //声明队列
                    channel.QueueDeclare(queue: "OrderOnly",
                                         durable: true,
                                         exclusive: false,
                                         autoDelete: false,
                                         arguments: null);

                    channel.QueueDeclare(queue: "OrderOnly2",
                                         durable: true,
                                         exclusive: false,
                                         autoDelete: false,
                                         arguments: null);

                    //声明交换机
                    channel.ExchangeDeclare(exchange: "OrderOnlyChange",
                                            type: ExchangeType.Direct,
                                            durable: true,
                                            autoDelete: false,
                                            arguments: null);

                    //队列绑定到交换机,路由Key:OrderOnlyKey
                    channel.QueueBind(queue: "OrderOnly",
                                      exchange: "OrderOnlyChange",
                                      routingKey: "OrderOnlyKey", arguments: null);

                    //绑定到交换机,路由Key:OrderOnlyKey2
                    channel.QueueBind(queue: "OrderOnly2",
                                      exchange: "OrderOnlyChange",
                                      routingKey: "OrderOnlyKey2", arguments: null);


                    /*重要!!!
                     * 绑定到交换机时可以绑多个routingKey,这样一个队列就会有多个的routeKey,
                     * 发消息是要匹配到任意一个key就会发送到该队列*/

                    //如下:给OrderOnly2队列又绑了一个OrderOnlyKey3的key
                    //channel.QueueBind(queue: "OrderOnly2",
                    //      exchange: "OrderOnlyChange",
                    //      routingKey: "OrderOnlyKey3", arguments: null);

                    Console.WriteLine("准备就绪,开始写入~~~");

                    #region 设置Rpc回复队列,定义消费者接受消息
                    string replyQueueName = "ReplyQueue";
                    //声明接受消息回复队列
                    channel.QueueDeclare(queue: replyQueueName, durable: true, exclusive: false, autoDelete: false, null);

                    //注意:回复的队列不能绑定到交换机,因为如果绑定了,发送的时候交换机会把消息也发送到这个队列,这样消息会造成混乱
                    //channel.QueueBind(queue: replyQueueName,
                    //             exchange: "OrderOnlyChange",
                    //             routingKey: string.Empty, arguments: null);

                    Dictionary <string, TaskCompletionSource <string> > resultDic = new Dictionary <string, TaskCompletionSource <string> >();
                    var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                    consumer.Received += (model, ea) =>
                    {
                        //每一次请求的唯一标识
                        string corrId = ea.BasicProperties.CorrelationId;

                        if (resultDic.Keys.Contains(corrId))//如果包含这个corrId,则把结果赋值给对应的TaskCompletionSource
                        {
                            var body    = ea.Body;
                            var message = Encoding.UTF8.GetString(body);

                            //把结果放入到结果集合中
                            resultDic[corrId].SetResult(message);
                            //Console.WriteLine($"接收到回复消息:{message}");
                        }
                    };

                    //处理消息
                    channel.BasicConsume(queue: replyQueueName,
                                         autoAck: true,
                                         consumer: consumer);
                    #endregion

                    for (int i = 0; i < count; i++)
                    {
                        string message = $"Task{i}";
                        byte[] body    = Encoding.UTF8.GetBytes(message);

                        //设置回复队列参数
                        var corrId = Guid.NewGuid().ToString();
                        var props  = channel.CreateBasicProperties();
                        props.ReplyTo       = replyQueueName; //你处理完过后把结果返回到这个队列中。
                        props.CorrelationId = corrId;         //这是我的请求标识

                        //channel.BasicPublish(exchange: "OrderOnlyChange",
                        //                routingKey: string.Empty,
                        //                basicProperties: null,
                        //                body: body);

                        //利用TaskCompletionSource的特性,异步获取消息时会等待
                        var result = new TaskCompletionSource <string>();
                        resultDic.Add(corrId, result);

                        //因为发送时指定路由key为OrderOnlyKey2,所以消息只会推送到OrderOnly2队列
                        channel.BasicPublish(exchange: "OrderOnlyChange",
                                             routingKey: "OrderOnlyKey2",
                                             basicProperties: props, //加上basicProperties参数,绑定回复队列
                                             body: body);

                        Console.WriteLine($"消息:{message} 已发送,corrId={corrId}");

                        Console.WriteLine($"接收到回复消息:{result.Task.Result}");
                    }
                }
            }
        }
Beispiel #36
0
        /// <summary>
        /// RabbitMQ接受消息
        /// </summary>
        /// <param name="queuqname"></param>
        /// <param name="limitnum">具体入队的队列名称</param>
        public static void ReceiveMsg(string queuqname, ushort limitnum = 3)
        {
            #region 处理方法
            try
            {
                #region 构建消息队列
                //1.实例化连接工厂
                var factory = new RabbitMQ.Client.ConnectionFactory();
                factory.HostName = RabbitMQ_Host;
                factory.UserName = RabbitMQ_User;
                factory.Password = RabbitMQ_Pwd;
                factory.AutomaticRecoveryEnabled = true;
                //2. 建立连接
                var connection = factory.CreateConnection();
                //3. 创建信道
                var channel = connection.CreateModel();

                var  queue_name = queuqname; //项目下游上传的队列信息
                bool durable    = true;      //队列是否持久化
                bool exclusive  = false;
                bool autoDelete = false;     //设置 autoDeleted=true 的队列,当没有消费者之后,队列会自动被删除
                                             //4. 申明队列
                channel.QueueDeclare(queue_name, durable, exclusive, autoDelete, null);
                //5. 构造消费者实例
                var  consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                bool autoAck  = false;
                //autoAck:true;自动进行消息确认,当消费端接收到消息后,就自动发送ack信号,不管消息是否正确处理完毕
                //autoAck:false;关闭自动消息确认,通过调用BasicAck方法手动进行消息确认
                //6. 绑定消息接收后的事件委托

                //8. 启动消费者
                //设置prefetchCount : 3 来告知RabbitMQ,在未收到消费端的N条消息确认时,不再分发消息,也就确保了当消费端处于忙碌状态时
                channel.BasicQos(0, limitnum, false);

                channel.BasicConsume(queue_name, autoAck, consumer);

                #endregion

                #region 队列-接收消息的处理方法
                //以这种形式传递方法
                //consumer.Received += (model, ea) => { Methed(model, ea, channel);};
                consumer.Received += (model, ea) =>
                {
                    try
                    {
                        //var body = ea.Body.ToArray();
                        var message = Encoding.UTF8.GetString(ea.Body.ToArray());
                        //获取消息后进行操作,do something
                        bool flag = false;
                        if (!string.IsNullOrEmpty(message))
                        {
                            try
                            {
                                //做其他存储或处理操作
                            }
                            catch (Exception ex)
                            {
                                //    //pub.ConnError("RabbitMQ", "Event_RabbitMQ_Method1", "项目下游请求数据-处理Message数据时,发生异常----" + ex.Message);
                                //    //pub.ConnError_TestSysShow("RabbitMq-RST", "Item-Attence", "项目下游请求数据-处理Message数据时,发生异常原数据message=" + message);
                            }
                        }
                        else
                        {
                            flag = true;
                        }
                        if (flag)
                        {
                            //操作完毕,则手动确认消息可删除
                            // 7. 发送消息确认信号(手动消息确认)
                            channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                        }
                    }
                    catch (Exception ex)
                    {
                        //JMB_ServiceClass.Common.pub.ConnError("RabbitMQ", "Event_RabbitMQ_Method1", "项目下游请求数据-接收数据后-发生异常:" + ex.Message);
                    }
                };
                #endregion

                //JMB_ServiceClass.Common.pub.ConnError("RabbitMQ", "Event_RabbitMQ_Method1", "项目下游请求数据-RabbitMQ监听消息启动成功");
            }
            catch (Exception ex)
            {
                //JMB_ServiceClass.Common.pub.ConnError("RabbitMQ", "Event_RabbitMQ_Method1", "项目下游请求数据-构建rabbitmq的queue异常:" + ex.Message);
                //RabbitMQ_Event1_IsRuning = false;
                //RabbitMQ_Event1_checkDate = DateTime.Now;
                //JMB_ServiceClass.Common.pub.ConnError("RabbitMQ", "Event_RabbitMQ_Method1", "项目下游请求数据-RabbitMQ监听消息——已关闭");
            }
            //finally
            //{
            //    connection.Close();//不能关,关了就停止接收消息了
            //    channel.Close();
            //}
            #endregion
        }
Beispiel #37
0
        static void Main(string[] args)
        {
            string type = Console.ReadLine();

            //factory.HostName = "10.16.21.19";
            switch (type)
            {
            case "1":
                #region 发布消息
                var factory = new RabbitMQ.Client.ConnectionFactory();
                factory.UserName = "******";
                factory.Password = "******";
                factory.Port     = 5672;
                factory.HostName = "47.101.160.52";
                do
                {
                    using (var connect = factory.CreateConnection())
                    {
                        using (var model = connect.CreateModel())
                        {
                            model.ExchangeDeclare("HistroyCity", "direct", true);
                            var q = model.QueueDeclare("CitiesQueue", true, false, false, null);
                            model.QueueBind("CitiesQueue", "HistroyCity", "CityPublished");
                            using (var cityTable = new HistoryAirDataEntities())
                            {
                                int count = (int)(q.MessageCount);
                                if (20 - count > 0)
                                {
                                    var list = (from c in cityTable.publish where c.ispublished == false select c).Take(20 - count).ToArray();
                                    if (list.Length == 0)
                                    {
                                        break;
                                    }
                                    foreach (var c in list)
                                    {
                                        var pm = new PublishMessage()
                                        {
                                            Name         = c.name,
                                            Url          = c.homeurl,
                                            PublishIndex = c.index,
                                            DataTime     = c.datatime
                                        };
                                        var message = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(pm));
                                        Console.WriteLine(pm.Name);
                                        model.BasicPublish("HistroyCity", "CityPublished", null, message);
                                        var pC = cityTable.publish.First(r => r.index == c.index);
                                        pC.ispublished = true;
                                    }
                                    cityTable.SaveChanges();
                                }
                            }
                        }
                    }
                    Console.WriteLine("*****************");
                    Thread.Sleep(1200000);
                } while (true);
                #endregion
                break;

            case "2":
                #region 更新起始时间,无效的功能
                var factory1 = new RabbitMQ.Client.ConnectionFactory();
                factory1.UserName = "******";
                factory1.Password = "******";
                factory1.Port     = 5672;
                factory1.HostName = "47.101.160.52";
                using (var connect = factory1.CreateConnection())
                {
                    using (var model = connect.CreateModel())
                    {
                        model.ExchangeDeclare("HistroyCity", "direct", true);
                        var q        = model.QueueDeclare("CitiesQueue", true, false, false, null);
                        var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(model);
                        model.BasicQos(0, 1, false);
                        consumer.Received += (channel, ea) =>
                        {
                            var body    = ea.Body;
                            var message = Encoding.UTF8.GetString(body);
                            var p       = JsonConvert.DeserializeObject <cities>(message);
                            Thread.Sleep(new Random().Next(4000, 10000));
                            using (var entry = new HistoryAirDataEntities())
                                using (var seleminun = new ChromeDriver())
                                //using (var seleminun = new PhantomJSDriver())
                                {
                                    seleminun.Navigate().GoToUrl(p.homeurl);
                                    Thread.Sleep(new Random().Next(1000, 2000));

                                    //获取起始时间
                                    var    times = seleminun.FindElements(By.XPath("//ul[@class=\"unstyled1\"]/li/a"));
                                    string timeT = null;
                                    if (times != null & times.Count > 0)
                                    {
                                        string[] t = times[0].GetAttribute("href").Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
                                        timeT = t.Last();
                                    }

                                    //获取当前页码上的信息并写入记录
                                    var rowEs = seleminun.FindElements(By.XPath("//div[@class=\"row\"]/div/table/tbody/tr"));
                                    Console.WriteLine(rowEs.Count);

                                    //string path = string.Format("{0}\\{1}", Environment.CurrentDirectory, "data");
                                    //using (var sw = new StreamWriter(string.Format("{0}//{1}", path, p.name), true))
                                    {
                                        for (int rowIndex = 1; rowIndex < rowEs.Count; rowIndex++)
                                        {
                                            var trEs     = rowEs[rowIndex].FindElements(By.XPath(".//td"));
                                            var tempdata = new data()
                                            {
                                                name = p.name
                                            };
                                            tempdata.date = DateTime.Parse(trEs[0].Text);
                                            tempdata.aqi  = trEs[1].Text;
                                            tempdata.rank = trEs[2].Text;
                                            int off = 0;
                                            if (trEs.Count == 10)
                                            {
                                                off            = 1;
                                                tempdata.range = trEs[3].Text;
                                            }

                                            int   p25, p10, so2, no2, O3_8h;
                                            float co;
                                            if (int.TryParse(trEs[3 + off].Text, out p25))
                                            {
                                                tempdata.pm2d5 = p25;
                                            }

                                            if (int.TryParse(trEs[4 + off].Text, out p10))
                                            {
                                                tempdata.pm10 = p10;
                                            }

                                            if (int.TryParse(trEs[5 + off].Text, out so2))
                                            {
                                                tempdata.so2 = so2;
                                            }

                                            if (float.TryParse(trEs[6 + off].Text, out co))
                                            {
                                                tempdata.co = co;
                                            }

                                            if (int.TryParse(trEs[7 + off].Text, out no2))
                                            {
                                                tempdata.no2 = no2;
                                            }

                                            if (int.TryParse(trEs[8 + off].Text, out O3_8h))
                                            {
                                                tempdata.o3_8 = O3_8h;
                                            }
                                            tempdata.updatetime = DateTime.Now;
                                            entry.data.Add(tempdata);

                                            //var tempData = new Data()
                                            //{
                                            //    Date = trEs[0].Text,
                                            //    AQI = trEs[1].Text,
                                            //    Rank = trEs[2 + off].Text,
                                            //    Pm2d5 = trEs[3 + off].Text,
                                            //    Pm10 = trEs[4 + off].Text,
                                            //    So2 = trEs[5 + off].Text,
                                            //    Co = trEs[6 + off].Text,
                                            //    No2 = trEs[7 + off].Text,
                                            //    O3_8h = trEs[8 + off].Text
                                            //};
                                            //if (trEs.Count == 10)
                                            //{
                                            //    tempData.Range = trEs[3].Text;
                                            //}
                                            //sw.WriteLine(JsonConvert.SerializeObject(tempData));
                                        }
                                        var target = entry.cities.First(rr => rr.name == p.name);
                                        target.starttime  = timeT;
                                        target.updatetime = DateTime.Now;
                                        Console.WriteLine("************");
                                        Console.WriteLine(target.name);
                                        Console.WriteLine("************");
                                    }
                                    entry.SaveChanges();
                                }
                            Thread.Sleep(1000);
                            model.BasicAck(ea.DeliveryTag, false);
                        };
                        model.BasicConsume("CitiesQueue", false, consumer);
                        var r = Console.ReadLine();
                        if (r.ToLower().Trim() == "over")
                        {
                            return;
                        }
                    }
                }
                #endregion
                break;

            case "3":
                #region 获取任务消息并进行数据获取
                var factory2 = new RabbitMQ.Client.ConnectionFactory()
                {
                    UserName = "******",
                    Password = "******",
                    Port     = 5672,
                    HostName = "47.101.160.52"
                };
                using (var connect = factory2.CreateConnection())
                {
                    using (var model = connect.CreateModel())
                    {
                        model.ExchangeDeclare("HistroyCity", "direct", true);
                        var q        = model.QueueDeclare("CitiesQueue", true, false, false, null);
                        var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(model);
                        model.BasicQos(0, 1, false);
                        consumer.Received += (channel, ea) =>
                        {
                            List <data> tempData = null;
                            try
                            {
                                var body    = ea.Body;
                                var message = Encoding.UTF8.GetString(body);
                                var p       = JsonConvert.DeserializeObject <PublishMessage>(message);

                                tempData = DataManager.GetHistroyData(p);
                                if (tempData != null)
                                {
                                    using (var enerty = new HistoryAirDataEntities())
                                        using (var trans = enerty.Database.BeginTransaction())
                                        {
                                            for (int i = 0; i < tempData.Count; i++)
                                            {
                                                enerty.data.Add(tempData[i]);
                                            }
                                            var reslut = enerty.SaveChanges();
                                            if (reslut > 0)
                                            {
                                                trans.Commit();
                                            }
                                            else
                                            {
                                                trans.Rollback();
                                            }
                                            model.BasicAck(ea.DeliveryTag, false);
                                        }
                                }
                                else
                                {
                                    model.BasicNack(ea.DeliveryTag, false, true);
                                }
                            }
                            catch (Exception err)
                            {
                                Console.WriteLine(err.Message);
                                Console.WriteLine(err.StackTrace);
                                model.BasicNack(ea.DeliveryTag, false, true);
                            }

                            #region old
                            //using (var entry = new HistoryAirDataEntities())
                            ////using (var seleminun = new ChromeDriver())
                            //using (var seleminun = new PhantomJSDriver())
                            //{
                            //    Thread.Sleep(new Random().Next(240000, 600000));
                            //    string t = HttpUtility.UrlDecode(string.Format("{0}{1}", p.DataTime.Value.Year, p.DataTime.Value.Month.ToString("00")));
                            //    string url = string.Format("{0}&month={1}", p.Url.Trim(), t);
                            //    seleminun.Navigate().GoToUrl(url);
                            //    Thread.Sleep(new Random().Next(1000, 2000));
                            //    var rowEs = seleminun.FindElements(By.XPath("//div[@class=\"row\"]/div/table/tbody/tr"));
                            //    Console.WriteLine(rowEs.Count);

                            //    string path = string.Format("{0}\\{1}", Environment.CurrentDirectory, "data");
                            //    using (var sw = new StreamWriter(string.Format("{0}//{1}", path, p.Name), true))
                            //    {
                            //        for (int rowIndex = 1; rowIndex < rowEs.Count; rowIndex++)
                            //        {
                            //            var trEs = rowEs[rowIndex].FindElements(By.XPath(".//td"));
                            //            var tempdata = new data() { name = p.Name };
                            //            tempdata.date = DateTime.Parse(trEs[0].Text);
                            //            tempdata.aqi = trEs[1].Text;
                            //            tempdata.rank = trEs[2].Text;
                            //            int p25, p10, so2, co, no2, O3_8h;
                            //            if (int.TryParse(trEs[3].Text, out p25))
                            //            {
                            //                tempdata.pm2d5 = p25;
                            //            }

                            //            if (int.TryParse(trEs[4].Text, out p10))
                            //            {
                            //                tempdata.pm10 = p10;
                            //            }

                            //            if (int.TryParse(trEs[5].Text, out so2))
                            //            {
                            //                tempdata.so2 = so2;
                            //            }

                            //            if (int.TryParse(trEs[6].Text, out co))
                            //            {
                            //                tempdata.co = co;
                            //            }

                            //            if (int.TryParse(trEs[7].Text, out no2))
                            //            {
                            //                tempdata.no2 = no2;
                            //            }

                            //            if (int.TryParse(trEs[8].Text, out O3_8h))
                            //            {
                            //                tempdata.no2 = no2;
                            //            }
                            //            entry.data.Add(tempdata);

                            //            var tempData = new Data()
                            //            {
                            //                Date = trEs[0].Text,
                            //                AQI = trEs[1].Text,
                            //                Rank = trEs[2].Text,
                            //                Pm2d5 = trEs[3].Text,
                            //                Pm10 = trEs[4].Text,
                            //                So2 = trEs[5].Text,
                            //                Co = trEs[6].Text,
                            //                No2 = trEs[7].Text,
                            //                O3_8h = trEs[8].Text
                            //            };
                            //            sw.WriteLine(JsonConvert.SerializeObject(tempData));
                            //        }
                            //    }
                            //    entry.SaveChanges();
                            //}
                            #endregion
                        };
                        model.BasicConsume("CitiesQueue", false, consumer);
                        var r = Console.ReadLine();
                        if (r.ToLower().Trim() == "over")
                        {
                            return;
                        }
                    }
                }
                #endregion
                break;

            case "4":
                #region 在数据库中插入任务计划
                using (var cityTable = new HistoryAirDataEntities())
                {
                    var list = (from c in cityTable.cities select c).ToArray();
                    for (int yIndex = 2018; yIndex < 2019; yIndex++)
                    {
                        for (int mIndex = 11; mIndex < 12; mIndex++)
                        {
                            foreach (var c in list)
                            {
                                if (yIndex == 2013)
                                {
                                    mIndex = 11;
                                }
                                else if (yIndex == DateTime.Now.Year)
                                {
                                    if (mIndex + 1 >= DateTime.Now.Month)
                                    {
                                        continue;
                                    }
                                }
                                var p = new publish();
                                p.name     = c.name;
                                p.homeurl  = c.homeurl;
                                p.datatime = new DateTime(yIndex, mIndex + 1, 1);
                                cityTable.publish.Add(p);
                            }
                        }
                    }
                    cityTable.SaveChanges();
                    Console.WriteLine(cityTable.publish.Count());
                    Console.WriteLine("*****************");
                }
                Console.WriteLine("*****************");
                #endregion
                break;

            default:
                break;
            }
            #region 获取城市列表并序列化为本地文件
            //var selHome = new ChromeDriver();
            //selHome.Navigate().GoToUrl("https://www.aqistudy.cn/historydata/");
            //var liEs = selHome.FindElements(By.XPath("//ul[@class=\"unstyled\"]/div/li/a"));
            //List<HistoryCity> cities = new List<HistoryCity>();
            //foreach (var item in liEs)
            //{
            //    var tempc = new HistoryCity();
            //    tempc.Name = item.Text.Trim();
            //    tempc.Url = item.GetAttribute("href");
            //    cities.Add(tempc);
            //}

            //selHome.Close();
            //foreach (var item in cities)
            //{
            //    using (var sw = new StreamWriter(string.Format("{0}\\{1}", path,item.Name)))
            //    {
            //        sw.Write(JsonConvert.SerializeObject(item));
            //    }
            //}
            #endregion

            #region 将本地文件写入到数据库中

            //List<HistoryCity> cities = new List<HistoryCity>();
            //string path = string.Format("{0}\\{1}", Environment.CurrentDirectory, "HistroyCities");
            //string[] files = Directory.GetFiles(path);
            //foreach (var item in files)
            //{
            //    using (var sr=new StreamReader(item))
            //    {
            //        var tempStr = sr.ReadToEnd();
            //        HistoryCity tempCity = JsonConvert.DeserializeObject<HistoryCity>(tempStr);
            //        cities.Add(tempCity);
            //    }
            //}

            //if (!Directory.Exists(path))
            //{
            //    Directory.CreateDirectory(path);
            //}
            //try
            //{
            //    using (var citiesEnty = new HistoryAirDataEntities())
            //    {
            //        int count = 0;
            //        foreach (var item in cities)
            //        {
            //            var tempcities = new cities();
            //            tempcities.name = item.Name;
            //            tempcities.homeurl = item.Url;
            //            citiesEnty.cities.Add(tempcities);
            //            count++;
            //            if (count >= 10)
            //            {
            //               // citiesEnty.SaveChanges();
            //                count = 0;
            //            }
            //        }
            //        citiesEnty.SaveChanges();
            //    }
            //}
            //catch (Exception err)
            //{

            //    Console.Write(err.Message);
            //}
            #endregion

            #region 获取城市历史数据
            //string path = Environment.CurrentDirectory + "//Data";
            //if (!Directory.Exists(path))
            //{
            //    Directory.CreateDirectory(path);
            //}
            //using (var seleminun = new ChromeDriver())
            //{
            //    seleminun.Navigate().GoToUrl("https://www.aqistudy.cn/historydata/daydata.php?city=%E5%AE%89%E9%98%B3&month=201703");
            //    Thread.Sleep(new Random().Next(1000, 2000));
            //    var rowEs = seleminun.FindElements(By.XPath("//div[@class=\"row\"]/div/table/tbody/tr"));
            //    Console.WriteLine(rowEs.Count);
            //    List<Data> datalist = new List<Data>();
            //    for (int rowIndex = 1; rowIndex < rowEs.Count; rowIndex++)
            //    {
            //        var trEs = rowEs[rowIndex].FindElements(By.XPath(".//td"));
            //        var tempData = new Data()
            //        {
            //            Date =DateTime.Parse(trEs[0].Text),
            //            AQI = trEs[1].Text,
            //            Rank = trEs[2].Text,
            //            Pm2d5 = trEs[3].Text,
            //            Pm10 = trEs[4].Text,
            //            So2 = trEs[5].Text,
            //            Co = trEs[6].Text,
            //            No2 = trEs[7].Text,
            //            O3_8h = trEs[8].Text
            //        };
            //        datalist.Add(tempData);
            //    }
            //    using (var sw=new StreamWriter(string.Format("{0}/{1}",path,"datalist")))
            //    {
            //        sw.Write(JsonConvert.SerializeObject(datalist));
            //    }

            //    //var tds = rowEs[rowEs.Count - 1].FindElements(By.XPath(".//td"));
            //    //for (int i = 0; i < tds.Count; i++)
            //    //{
            //    //    Console.WriteLine(tds[i].Text);
            //    //}
            //    Console.ReadLine();
            //}
            #endregion

            #region 更新起始时间(未完成)
            //List<HistoryCity> cities = new List<HistoryCity>();
            //string path = string.Format("{0}\\{1}", Environment.CurrentDirectory, "HistroyCities");
            //string[] files = Directory.GetFiles(path);
            //foreach (var item in files)
            //{
            //    using (var sr = new StreamReader(item))
            //    {
            //        var tempStr = sr.ReadToEnd();
            //        HistoryCity tempCity = JsonConvert.DeserializeObject<HistoryCity>(tempStr);
            //        cities.Add(tempCity);
            //    }
            //}
            //using (var cityTable=new HistoryAirDataEntities())
            //{
            //    for (int i = 0; i < cities.Count; i++)
            //    {
            //        var city = (from c in cityTable.cities where c.name == cities[i].Name & c.startTime==null select c).ToArray();
            //        if (city.Length==1)
            //        {
            //            using (var selenum=new ChromeDriver())
            //            {
            //                selenum.Navigate().GoToUrl(city[0].homeurl);
            //                if (true)
            //                {

            //                }
            //            }
            //            city[0].startTime = null;
            //        }

            //    }
            //}


            #endregion
        }
Beispiel #38
0
        static void Main(string[] args)
        {
            Console.WriteLine("1 发布任务消息;2 将查询结果放入消息队列;3 获取队列中的数据将其放入数据库;4 生产任务计划");
            string        type   = Console.ReadLine();
            Configuration config = System.Configuration.ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

            //设置计算引擎json记录路径

            //factory.HostName = "10.16.21.19";
            switch (type)
            {
            case "1":
                #region 发布任务消息
                var factory = new RabbitMQ.Client.ConnectionFactory();
                factory.UserName = "******";
                factory.Password = "******";
                factory.Port     = 5672;
                factory.HostName = "47.101.160.52";
                do
                {
                    using (var connect = factory.CreateConnection())
                    {
                        using (var model = connect.CreateModel())
                        {
                            model.ExchangeDeclare("HistroyCity", "direct", true);
                            var q = model.QueueDeclare("CitiesQueue", true, false, false, null);
                            model.QueueBind("CitiesQueue", "HistroyCity", "CityPublished");
                            using (var cityTable = new HistoryDataEntities())
                            {
                                int count = (int)(q.MessageCount);
                                if (50 - count > 0)
                                {
                                    try
                                    {
                                        var list = (from c in cityTable.publish where c.ispublished == false select c).OrderByDescending(r => r.datatime).Take(50 - count).ToArray();
                                        if (list.Length == 0)
                                        {
                                            break;
                                        }
                                        foreach (var c in list)
                                        {
                                            var pm = new PublishMessage()
                                            {
                                                Name         = c.name,
                                                Url          = c.homeurl,
                                                PublishIndex = c.index,
                                                DataTime     = c.datatime
                                            };
                                            var message = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(pm));
                                            Console.WriteLine("{0}  time:   {1}", pm.Name, DateTime.Now);
                                            model.BasicPublish("HistroyCity", "CityPublished", null, message);
                                            var pC = cityTable.publish.First(r => r.index == c.index);
                                            pC.ispublished = true;
                                        }
                                        cityTable.SaveChanges();
                                    }
                                    catch (Exception err)
                                    {
                                        Console.WriteLine(err.Message);
                                    }
                                }
                            }
                        }
                    }
                    Console.WriteLine("*****************");
                    Thread.Sleep(1200000);
                } while (true);
                #endregion
                break;

            case "2":
                #region 将消息放入到消息队列中(日值数据)
                var userName = config.AppSettings.Settings["UserName"];
                var Password = config.AppSettings.Settings["Password"];
                var Port     = config.AppSettings.Settings["Port"];
                var HostName = config.AppSettings.Settings["HostName"];
                var factory2 = new RabbitMQ.Client.ConnectionFactory()
                {
                    UserName = userName.Value,
                    Password = Password.Value,
                    Port     = int.Parse(Port.Value),
                    HostName = HostName.Value
                };
                using (var connect = factory2.CreateConnection())
                {
                    using (var model = connect.CreateModel())
                    {
                        model.ExchangeDeclare("HistroyCity", "direct", true);
                        var q        = model.QueueDeclare("CitiesQueue", true, false, false, null);
                        var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(model);
                        model.BasicQos(0, 1, false);
                        consumer.Received += (channel, ea) =>
                        {
                            var              body     = ea.Body;
                            var              message  = Encoding.UTF8.GetString(body);
                            var              p        = JsonConvert.DeserializeObject <PublishMessage>(message);
                            List <data>      datalist = new List <data>();
                            PhantomJSOptions option   = new PhantomJSOptions();
                            option.AddAdditionalCapability("phantomjs.page.settings.userAgent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36");
                            //using (var seleminun = new PhantomJSDriver(option))
                            using (var seleminun = new ChromeDriver())
                            {
                                string t    = HttpUtility.UrlDecode(string.Format("{0}{1}", p.DataTime.Value.Year, p.DataTime.Value.Month.ToString("00")));
                                var    name = HttpUtility.UrlEncode(p.Name.Trim());
                                Console.WriteLine("{0}\t time:\t{1}", p.Name, DateTime.Now);
                                string url = string.Format("https://www.aqistudy.cn/historydata/daydata.php?city={0}&month={1}", name, t);
                                seleminun.Navigate().GoToUrl(url);
                                Thread.Sleep(new Random().Next(90000, 180000));
                                var rowEs = seleminun.FindElements(By.XPath("//div[@class=\"row\"]/div/table/tbody/tr"));
                                Console.WriteLine(rowEs.Count);
                                for (int rowIndex = 1; rowIndex < rowEs.Count; rowIndex++)
                                {
                                    var trEs     = rowEs[rowIndex].FindElements(By.XPath(".//td"));
                                    var tempdata = new data()
                                    {
                                        name = p.Name
                                    };
                                    tempdata.date = DateTime.Parse(trEs[0].Text);
                                    tempdata.aqi  = trEs[1].Text;
                                    tempdata.rank = trEs[2].Text;
                                    int    p25, p10, so2, no2, O3_8h;
                                    double co;
                                    if (int.TryParse(trEs[3].Text, out p25))
                                    {
                                        tempdata.pm2d5 = p25;
                                    }

                                    if (int.TryParse(trEs[4].Text, out p10))
                                    {
                                        tempdata.pm10 = p10;
                                    }

                                    if (int.TryParse(trEs[5].Text, out so2))
                                    {
                                        tempdata.so2 = so2;
                                    }

                                    if (double.TryParse(trEs[6].Text, out co))
                                    {
                                        tempdata.co = co;
                                    }

                                    if (int.TryParse(trEs[7].Text, out no2))
                                    {
                                        tempdata.no2 = no2;
                                    }

                                    if (int.TryParse(trEs[8].Text, out O3_8h))
                                    {
                                        tempdata.o3_8 = O3_8h;
                                    }
                                    tempdata.updatetime = DateTime.Now;
                                    datalist.Add(tempdata);
                                }
                            }
                            if (datalist.Count > 0)
                            {
                                var publisher = new PublishData();
                                publisher.Publish(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(datalist)));
                            }
                            model.BasicAck(ea.DeliveryTag, false);
                        };

                        model.BasicConsume("CitiesQueue", false, consumer);
                        var r = Console.ReadLine();
                        if (r.ToLower().Trim() == "over")
                        {
                            return;
                        }
                    }
                }
                #endregion
                break;

            case "3":
                #region 获取队列中的数据

                var factory4 = new RabbitMQ.Client.ConnectionFactory()
                {
                    UserName = "******",
                    Password = "******",
                    Port     = 5672,
                    HostName = "47.101.160.52"
                };
                using (var connect = factory4.CreateConnection())
                {
                    using (var model = connect.CreateModel())
                    {
                        model.ExchangeDeclare("HistroyCity", "direct", true);
                        var q        = model.QueueDeclare("CitiesDataQueue", true, false, false, null);
                        var consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(model);
                        model.BasicQos(0, 1, false);
                        consumer.Received += (channel, ea) =>
                        {
                            var body     = ea.Body;
                            var message  = Encoding.UTF8.GetString(body);
                            var datalist = JsonConvert.DeserializeObject <List <data> >(message);

                            using (var enty = new HistoryDataEntities())
                            {
                                foreach (var item in datalist)
                                {
                                    enty.data.Add(item);
                                    Console.WriteLine("{0}  time:{1}", item.name, DateTime.Now);
                                }
                                enty.SaveChanges();
                            }
                            model.BasicAck(ea.DeliveryTag, false);
                            GC.Collect();
                        };

                        model.BasicConsume("CitiesDataQueue", false, consumer);
                        var r = Console.ReadLine();
                        if (r.ToLower().Trim() == "over")
                        {
                            return;
                        }
                    }
                }
                #endregion
                break;

            case "4":
                #region 在数据库中插入任务计划
                Console.WriteLine("请输入时间:YYYY-MM-DD");
                string dateStr = Console.ReadLine();
                var    splits  = dateStr.Split(new string[] { "-", "—", "_" }, StringSplitOptions.RemoveEmptyEntries);
                if (splits.Length != 3)
                {
                    break;
                }
                using (var cityTable = new HistoryDataEntities())
                {
                    var list = (from c in cityTable.cities select c).ToArray();
                    foreach (var c in list)
                    {
                        var p = new publish();
                        p.name        = c.name;
                        p.homeurl     = c.homeurl;
                        p.datatime    = new DateTime(int.Parse(splits[0]), int.Parse(splits[1]), 1);
                        p.ispublished = false;
                        cityTable.publish.Add(p);
                    }
                    cityTable.SaveChanges();
                    Console.WriteLine(cityTable.publish.Count());
                    Console.WriteLine("*****************");
                }
                Console.WriteLine("*****************");
                #endregion
                break;

            default:
                break;
            }
        }
Beispiel #39
0
        static void Main(string[] args)
        {
            string queuqname = "firstQueue";
            ushort limitnum  = 3;

            try
            {
                #region 构建消息队列
                //1.实例化连接工厂
                var factory = new RabbitMQ.Client.ConnectionFactory();
                factory.HostName = "localhost";
                factory.UserName = "******";
                factory.Password = "******";
                factory.AutomaticRecoveryEnabled = true;
                //2. 建立连接
                var connection = factory.CreateConnection();
                //3. 创建信道
                var channel = connection.CreateModel();

                var  queue_name = queuqname; //项目下游上传的队列信息
                bool durable    = true;      //队列是否持久化
                bool exclusive  = false;
                //设置 autoDeleted=true 的队列,当没有消费者之后,队列会自动被删除
                bool autoDelete = false;
                //4. 申明队列
                channel.QueueDeclare(queue_name, durable, exclusive, autoDelete, null);
                //5. 构造消费者实例
                var  consumer = new RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                bool autoAck  = false;
                //autoAck:true;自动进行消息确认,当消费端接收到消息后,就自动发送ack信号,不管消息是否正确处理完毕
                //autoAck:false;关闭自动消息确认,通过调用BasicAck方法手动进行消息确认
                //6. 绑定消息接收后的事件委托

                //8. 启动消费者
                //设置prefetchCount : 3 来告知RabbitMQ,在未收到消费端的N条消息确认时,不再分发消息,也就确保了当消费端处于忙碌状态时
                channel.BasicQos(0, limitnum, false);

                channel.BasicConsume(queue_name, autoAck, consumer);

                #endregion

                #region 队列-接收消息的处理方法

                consumer.Received += (model, ea) =>
                {
                    try
                    {
                        //var body = ea.Body.ToArray();
                        var message = Encoding.UTF8.GetString(ea.Body.ToArray());
                        //获取消息后进行操作,do something
                        bool flag = false;
                        if (!string.IsNullOrEmpty(message))
                        {
                            try
                            {
                                //做其他存储或处理操作
                                //File.WriteAllText(@"C:\Users\Administrator\Desktop\333.txt", message, Encoding.UTF8);
                                Console.WriteLine("接收消息:" + message);
                                flag = true;
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                        else
                        {
                            flag = true;
                        }
                        if (flag)
                        {
                            //操作完毕,则手动确认消息可删除
                            // 7. 发送消息确认信号(手动消息确认)
                            channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                };
                #endregion
            }
            catch (Exception ex)
            {
            }
            //finally
            //{
            //    connection.Close();//不能关,关了就停止接收消息了
            //    channel.Close();
            //}


            Console.ReadKey();
        }
Beispiel #40
-1
        static void Main(string[] args)
        {
            var factory = new ConnectionFactory() { HostName = "localhost" };
            using (var connection = factory.CreateConnection())
            using (var channel = connection.CreateModel())
            {
                channel.ExchangeDeclare(exchange: "logs", type: "fanout");
                channel.QueueDeclare(queue: "1ToMany2",
                                                     durable: false,
                                                     exclusive: false,
                                                     autoDelete: false,
                                                     arguments: null);

                channel.QueueBind(queue: "1ToMany2",
                                  exchange: "logs",
                                  routingKey: "");

                var consumer = new EventingBasicConsumer(channel);
                consumer.Received += (model, ea) =>
                {
                    var body = ea.Body;
                    var message = Encoding.UTF8.GetString(body);
                    Console.WriteLine(" [x] Received {0}", message);
                };
                channel.BasicConsume(queue: "1ToMany2",
                                     noAck: true,
                                     consumer: consumer);

                Console.WriteLine(" Press [enter] to exit.");
                Console.ReadLine();
            }
        }