public void Should_throw_exception_if_delivery_tags_is_null()
{
var channel = Substitute.For<IModel>();
channel.IsOpen.Returns(true);
var subscription = new Subscription(channel);
// Action
subscription.Ack(null);
}
public ReceivedTransportMessage ReceiveMessage(ITransactionContext context)
{
try
{
if (!context.IsTransactional)
{
using (var localModel = GetConnection().CreateModel())
{
var basicGetResult = localModel.BasicGet(inputQueueName, true);
if (basicGetResult == null)
{
Thread.Sleep(BackoffTime);
return(null);
}
return(GetReceivedTransportMessage(basicGetResult.BasicProperties, basicGetResult.Body));
}
}
EnsureThreadBoundModelIsInitialized(context);
if (threadBoundSubscription == null || !threadBoundSubscription.Model.IsOpen)
{
threadBoundSubscription = new Subscription(threadBoundModel, inputQueueName, false);
}
BasicDeliverEventArgs ea;
if (!threadBoundSubscription.Next((int)BackoffTime.TotalMilliseconds, out ea))
{
return(null);
}
// wtf??
if (ea == null)
{
return(null);
}
context.BeforeCommit += () => threadBoundSubscription.Ack(ea);
context.AfterRollback += () =>
{
threadBoundModel.BasicNack(ea.DeliveryTag, false, true);
threadBoundModel.TxCommit();
};
return(GetReceivedTransportMessage(ea.BasicProperties, ea.Body));
}
catch (Exception e)
{
ErrorOnConnection(e);
throw;
}
}
public void Listen(string queueName)
{
var subscription = new Subscription(_model, queueName, false);
while (true)
{
Console.WriteLine("Listen");
BasicDeliverEventArgs eventArgs = subscription.Next();
OnGetMsg(eventArgs);
subscription.Ack(eventArgs);
}
}
private void ListenUpdated(Subscription subscriptionUpdated)
{
BasicDeliverEventArgs eventArgsUpdated = subscriptionUpdated.Next();
if (eventArgsUpdated != null)
{
string messageContent = Encoding.UTF8.GetString(eventArgsUpdated.Body);
ClienteAtualizadoEvent _updated = JsonConvert.DeserializeObject <ClienteAtualizadoEvent>(messageContent);
_repository.Update(_updated.ToCustomerEntity(_repository.GetCustomer(_updated.Id)));
subscriptionUpdated.Ack(eventArgsUpdated);
}
}
private void Poll()
{
while (Enabled)
{
var deliveryArgs = _subscription.Next();
var message = Encoding.Default.GetString(deliveryArgs.Body);
Console.WriteLine("Message Recieved - {0}", message);
_subscription.Ack(deliveryArgs);
}
}
private void ListenDeleted(Subscription subscriptionDeleted)
{
BasicDeliverEventArgs eventArgsDeleted = subscriptionDeleted.Next();
if (eventArgsDeleted != null)
{
string messageContent = Encoding.UTF8.GetString(eventArgsDeleted.Body);
CustomerDeletedEvent _deleted = JsonConvert.DeserializeObject <CustomerDeletedEvent>(messageContent);
_repository.Remove(_deleted.Id);
subscriptionDeleted.Ack(eventArgsDeleted);
}
}
private void ListenCreated(Subscription subscriptionCreated)
{
BasicDeliverEventArgs eventArgsCreated = subscriptionCreated.Next();
if (eventArgsCreated != null)
{
string messageContent = Encoding.UTF8.GetString(eventArgsCreated.Body);
CustomerCreatedEvent _created = JsonConvert.DeserializeObject <CustomerCreatedEvent>(messageContent);
_repository.Create(_created.ToCustomerEntity());
subscriptionCreated.Ack(eventArgsCreated);
}
}
public void ProcessMessages()
{
using (_connection = _factory.CreateConnection())
{
using (var channel = _connection.CreateModel())
{
Console.WriteLine("Listening for Topic <payment.cardpayment>");
Console.WriteLine("-----------------------------------------");
Console.WriteLine();
//idempotent operation: if the exchange already exists then it won't be recreated
channel.ExchangeDeclare(exchange: ExchangeName, type: "topic");
//idempotent operation
channel.QueueDeclare(queue: CardPaymentQueueName,
durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queue: CardPaymentQueueName, exchange: ExchangeName,
routingKey: "payment.cardpayment");
//the basic Qos with a prefix count = 1, i.e. consumer will reserve one message after queue
//to process at a time, If any of those messages are not acknowledged when they are finished processing,
//then they will be put back onto the queue ready for another consumer to process them.
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
//channel.BasicQos(prefetchSize: 0, prefetchCount: 10, global: false);
//Subscription is a high level abstraction that has a more natural iterator feel to it.
//To use it we simply create a new instance and supply the channel
//and the queue which we want to get the messages from.
//noAck: false => consumer will acknowledge when it finishes processing
Subscription subscription = new Subscription(model: channel,
queueName: CardPaymentQueueName, noAck: false);
while (true) //run an infinite loop to listen to messages in the queue
{
//we enter a while called next and the subscriptions get the next message
BasicDeliverEventArgs deliveryArguments = subscription.Next();
//The serialized message throughout the card payment or (a purchase order if it is a purchase order consumer).
var message = (CardPayment)deliveryArguments.Body.DeSerialize(typeof(CardPayment));
var routingKey = deliveryArguments.RoutingKey;
Console.WriteLine("--- Payment - Routing Key <{0}> : {1} : {2}", routingKey, message.CardNumber, message.Amount);
// Once we have finished with the message,we call the ACK method and the subscription
// to acknowledge the message
subscription.Ack(deliveryArguments);
}
}
}
}
public void ReceivePublishSubscribeMessageReceiverTwo(IModel model)
{
model.BasicQos(0, 1, false);
Subscription subscription = new Subscription(model, _publishSubscribeQueueTwo, false);
while (true)
{
BasicDeliverEventArgs deliveryArguments = subscription.Next();
String message = Encoding.UTF8.GetString(deliveryArguments.Body);
Console.WriteLine("Message from queue: {0}", message);
subscription.Ack(deliveryArguments);
}
}
static void Main(string[] args)
{
const string MQ_HOST = "crmdevapp01";
const string MQ_USER_NAME = "user";
const string MQ_USER_PASSWORD = "******";
const string MQ_EXCHANGE_NAME = "API";
const string MQ_QUEUE_NAME = "RS_Test";
var factory = new ConnectionFactory {
HostName = MQ_HOST, UserName = MQ_USER_NAME, Password = MQ_USER_PASSWORD, Port = AmqpTcpEndpoint.UseDefaultPort
};
using (var con = factory.CreateConnection())
using (var channel = con.CreateModel())
{
do
{
string response = null;
var correlationId = Guid.NewGuid().ToString();
var message = Console.ReadLine();
channel.BasicPublish(
exchange: MQ_EXCHANGE_NAME,
routingKey: "Smev",
body: Encoding.UTF8.GetBytes(message),
basicProperties: new BasicProperties
{
ReplyTo = MQ_QUEUE_NAME,
DeliveryMode = 2,
CorrelationId = correlationId,
Headers = new Dictionary <string, object> {
{ "Method", "Test" }
}
}
);
var sub = new Subscription(channel, MQ_QUEUE_NAME, false);
foreach (BasicDeliverEventArgs e in sub)
{
if (e.BasicProperties.CorrelationId == correlationId)
{
response = e.GetMessage();
sub.Ack(e);
break;
}
}
Console.WriteLine(response);
} while (true);
}
}
public async Task <int> Listen(int timeout, CancellationToken cancellationToken)
{
try
{
var factory = new ConnectionFactory
{
HostName = _defaultConfig.Hostname,
UserName = _defaultConfig.User,
Password = _defaultConfig.Password,
Port = _defaultConfig.Port
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: _defaultConfig.TopicName,
durable: _defaultConfig.Durable,
exclusive: false,
autoDelete: false,
arguments: null);
var messageCounter = 0;
var subscription = new Subscription(channel, _defaultConfig.TopicName, false);
var finishAt = DateTime.Now.AddSeconds(timeout);
while ((timeout == 0 || DateTime.Now < finishAt) && !cancellationToken.IsCancellationRequested)
{
subscription.Next(5000, out var basicDeliveryEventArgs);
if (basicDeliveryEventArgs != null)
{
string messageContent = Encoding.UTF8.GetString(basicDeliveryEventArgs.Body);
_messageHandler.Handle(_defaultConfig.TopicName, messageContent);
subscription.Ack(basicDeliveryEventArgs);
if (timeout > 0) //count messages only if there is timeout defined
{
messageCounter++;
}
}
}
await Task.Delay(timeout * 1000, cancellationToken);
return(await Task.FromResult(messageCounter));
}
}
catch (Exception e)
{
_logger.LogError(e.ToString());
throw;
}
}
/// <summary>
/// Receive Messages
/// </summary>
/// <param name="queueName"></param>
/// <param name="subject"></param>
public async Task ReceiveMessages(string queueName, Subject <MessageQueue> subject, IMessageQueueProcessing _messageProcessor)
{
Console.WriteLine("Receiving Messages at " + DateTime.Now);
if (_running == true)
{
return;
}
_running = true;
var response = _channel.QueueDeclarePassive(queueName);
_channel.QueueDeclare(queue: queueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
_subscription = new Subscription(_channel, queueName, false);
foreach (BasicDeliverEventArgs e in _subscription)
{
string message = Encoding.UTF8.GetString(e.Body);
MessageQueue messageQueue = JsonConvert.DeserializeObject <MessageQueue>(message);
messageQueue.MessageGuid = Guid.NewGuid();
if (messageQueue.QueueName == string.Empty || messageQueue.QueueName == null)
{
messageQueue.QueueName = _originatingQueueName;
}
Console.WriteLine("Receiving Message id " + messageQueue.TransactionQueueId);
ResponseModel <MessageQueue> responseMessage = await _messageProcessor.CommitInboundMessage(messageQueue, _connectionStrings);
if (responseMessage.ReturnStatus == true)
{
if (_sendToLoggingQueue == true)
{
responseMessage = SendReceivedMessageToLoggingQueue(messageQueue);
}
if (responseMessage.ReturnStatus == true)
{
Console.WriteLine($"Message Committed: {messageQueue.TransactionQueueId}");
_subscription.Ack(e);
}
await _messageProcessor.ProcessMessages(_inboundSemaphoreKey, _connectionStrings);
}
}
}
public void SubscribeWithSubscriber()
{
WithChannel.Do(channel =>
{
var subscription = new Subscription(channel, ackNackQueue);
foreach (BasicDeliverEventArgs deliverEventArgs in subscription)
{
var message = Encoding.UTF8.GetString(deliverEventArgs.Body);
Console.Out.WriteLine("message = {0}", message);
subscription.Ack(deliverEventArgs);
}
});
}
/// <summary>
/// Listen for incoming messages.
/// </summary>
/// <param name="token">
/// The cancellation token to signal the worker to exit.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
private async Task ReceiveMessagesAsync(CancellationToken token)
{
using (var connection = this.connectionFactory.CreateConnection())
using (var amqpModel = connection.CreateModel())
{
amqpModel.ExchangeDeclare(this.ExchangeName, this.ExchangeType);
amqpModel.QueueDeclare(this.QueueName, true, false, false, null);
amqpModel.BasicQos(0, 1, false);
amqpModel.QueueBind(this.QueueName, this.ExchangeName, this.RoutingKey);
this.logger.LogInformation($"Waiting for messages on queue '{this.QueueName}' with routing key '{this.RoutingKey}'.");
var amqpSubscription = new Subscription(amqpModel, this.QueueName);
while (true)
{
var response = amqpSubscription.Next(SubscriptionNextTimeoutMilliseconds, out BasicDeliverEventArgs ea);
if (response == false)
{
if (amqpModel.IsClosed)
{
this.logger.LogWarning($"AMQP channel {amqpModel.ChannelNumber} is closed.");
return;
}
continue;
}
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
this.logger.LogDebug($"RECEIVE: {ea.RoutingKey}: {message}");
var success = this.eventHandler.HandleMessage(message);
if (success)
{
amqpSubscription.Ack(ea);
}
////await task;
////var success = task.IsCompleted;
////if (success)
////{
//// amqpModel.BasicAck(ea.DeliveryTag, false);
////}
await Task.Delay(10, token);
}
}
// ReSharper disable once FunctionNeverReturns
}
private static void RabbitListener()
{
IModel model = GetRabbitChannel(exchangeName, queueName, routingKey);
var subscription = new Subscription(model, queueName, false);
while (true)
{
BasicDeliverEventArgs basicDeliveryEventArgs = subscription.Next();
string messageContent = Encoding.UTF8.GetString(basicDeliveryEventArgs.Body);
//messagesTextBox.Invoke((MethodInvoker)delegate { messagesTextBox.Text += messageContent + "\r\n"; });
Console.WriteLine(messageContent);
subscription.Ack(basicDeliveryEventArgs);
}
}
/// <summary>
///
/// </summary>
private void Consume()
{
bool autoAck = false;
//create a subscription
mSubscription = new Subscription(Model, QueueName, autoAck);
while (isConsuming)
{
BasicDeliverEventArgs e = mSubscription.Next();
byte[] body = e.Body;
onMessageReceived(body);
mSubscription.Ack(e);
}
}
/// <summary>
/// Get Messages In Queue
/// </summary>
/// <param name="state"></param>
private async void GetMessagesInQueue(object state)
{
if (_running == true)
{
return;
}
_running = true;
Console.WriteLine("Receiving Messages at " + DateTime.Now);
Subscription subscription = _messageQueueConfigurations[0].GetSubscription();
foreach (BasicDeliverEventArgs e in subscription)
{
string message = Encoding.UTF8.GetString(e.Body);
MessageQueue messageQueue = JsonConvert.DeserializeObject <MessageQueue>(message);
if (messageQueue.QueueName == string.Empty || messageQueue.QueueName == null)
{
string originatingQueue = _messageQueueConfigurations[0].GetOriginatingQueueName();
if (originatingQueue != MessageQueueEndpoints.LoggingQueue)
{
messageQueue.QueueName = originatingQueue;
}
}
Console.WriteLine("Receiving Message id " + messageQueue.TransactionQueueId);
ResponseModel <MessageQueue> responseMessage = await _messageProcessor.CommitInboundMessage(messageQueue, _connectionStrings);
if (responseMessage.ReturnStatus == true)
{
if (_appConfig.SendToLoggingQueue == true && messageQueue.TransactionCode != TransactionQueueTypes.Acknowledgement)
{
responseMessage = _messageQueueConfigurations[0].SendReceivedMessageToLoggingQueue(messageQueue, MessageQueueExchanges.Logging);
}
if (responseMessage.ReturnStatus == true)
{
Console.WriteLine($"Message Committed: {messageQueue.TransactionQueueId}");
subscription.Ack(e);
}
await _messageProcessor.ProcessMessages(_appConfig.InboundSemaphoreKey, _connectionStrings);
}
}
}
public static int Main(string[] args)
{
if (args.Length < 4)
{
Console.Error.WriteLine("Usage: LogTail <uri> <exchange> <exchangetype> <routingkey>");
Console.Error.WriteLine("RabbitMQ .NET client version " + typeof(IModel).Assembly.GetName().Version.ToString());
Console.Error.WriteLine("Parameters:");
Console.Error.WriteLine(" <uri> = \"amqp://*****:*****@host:port/vhost\"");
Console.Error.WriteLine("If the exchange name is the empty string, will instead declare a queue named");
Console.Error.WriteLine("by the routingkey, and consume from that queue.");
return(2);
}
string serverAddress = args[0];
string exchange = args[1];
string exchangeType = args[2];
string routingKey = args[3];
ConnectionFactory cf = new ConnectionFactory();
cf.Uri = serverAddress;
using (IConnection conn = cf.CreateConnection())
{
using (IModel ch = conn.CreateModel()) {
ch.QueueDeclare(routingKey, false, true, true, null);
Subscription sub = new Subscription(ch, routingKey);
if (exchange != "")
{
ch.ExchangeDeclare(exchange, exchangeType);
ch.QueueBind(routingKey, exchange, routingKey, null);
}
Console.WriteLine("Consumer tag: " + sub.ConsumerTag);
foreach (BasicDeliverEventArgs e in sub)
{
sub.Ack(e);
ProcessSingleDelivery(e);
if (Encoding.UTF8.GetString(e.Body) == "quit")
{
Console.WriteLine("Quitting!");
break;
}
}
return(0);
}
}
}
private static void blockingReceiveMessages(Subscription sub, long msgCount)
{
Console.WriteLine("Receiving {0} messages (using a Subscriber)", msgCount);
for (int i = 0; i < msgCount; ++i)
{
Console.WriteLine("Message {0}: {1} (via Subscription.Next())",
i, messageText(sub.Next()));
Console.WriteLine("Message {0} again: {1} (via Subscription.LatestEvent)",
i, messageText(sub.LatestEvent));
sub.Ack();
}
Console.WriteLine("Done.\n");
}
public void GetData()
{
try
{
var basicDeliveryEventArgs = SubscriptionForSecondQueue.Next();
var messageContent = Encoding.UTF8.GetString(basicDeliveryEventArgs.Body);
if (messageContent == _CommandStop)
{
SubscriptionForSecondQueue.Ack(basicDeliveryEventArgs);
SubscriptionForSecondQueue.Close();
FirstQueue.Model.Close();
FirstQueue.Connection.Close();
ServiceWork = false;
return;
}
Console.WriteLine("Get data from queue #2: " + messageContent);
SubscriptionForSecondQueue.Ack(basicDeliveryEventArgs);
}
catch (Exception exception)
{
Console.WriteLine(exception);
ServiceWork = false;
}
}
private void RunConsumer(
string queueName)
{
new Task(() =>
{
var _channel = this.c_connection.CreateModel();
var _consumer = new Subscription(_channel, queueName);
foreach (BasicDeliverEventArgs _messageDelivery in _consumer)
{
this.c_writeLog(string.Format("Received message on q {0}, tag = {1}", queueName, _messageDelivery.DeliveryTag));
_consumer.Ack(_messageDelivery);
}
}).Start();
}
private static void RabbitListener()
{
string hostName = "localhost";
string exchangeName = "backend-api";
IModel channel = GetRabbitChannel(hostName, exchangeName);
var subscription = new Subscription(channel, exchangeName, false);
while (true)
{
BasicDeliverEventArgs basicDeliveryEventArgs = subscription.Next();
string msg = Encoding.UTF8.GetString(basicDeliveryEventArgs.Body);
string value = GetValueByKeyAndHostName(msg, hostName);
Console.WriteLine(msg + " : " + value);
subscription.Ack(basicDeliveryEventArgs);
}
}
private void Poll()
{
while (Enabled)
{
//Get next message
var deliveryArgs = _subscription.Next();
//Deserialize message
var message = Encoding.Default.GetString(deliveryArgs.Body);
var dsMessage = JsonConvert.DeserializeObject <T>(message);
OnReceiveMessage.Invoke(this, new RecieveMessageArgs <T> {
Data = dsMessage
});
//Acknowledge message is processed
_subscription.Ack(deliveryArgs);
}
}
private IMessage Receive (IModel model, int timeout, bool doAck)
{
string finalName = model.QueueDeclare (QRef.Queue, false);
using (Subscription sub = new Subscription (model, finalName)) {
BasicDeliverEventArgs result;
if (sub.Next (timeout, out result)) {
IMessage m = helper.ReadMessage (QRef, result);
if (doAck)
sub.Ack (result);
return m;
} else {
throw new MonoMessagingException ("No Message Available");
}
}
}
private void Poll()
{
while (Enabled)
{
//Get next message
var deliveryArgs = _subscription.Next();
//Deserialize message
var message = Encoding.Default.GetString(deliveryArgs.Body);
//Handle Message
Console.WriteLine("Message Recieved - {0}", message);
//Acknowledge message is processed
_subscription.Ack(deliveryArgs);
}
}
public void RabbitListener()
{
var model = GetRabbitChannel(exchangeName, queueName, routingKey);
var subscription = new Subscription(model, queueName, false);
while (true)
{
BasicDeliverEventArgs basicDeliveryEventArgs = subscription.Next();
string messageContent = Encoding.UTF8.GetString(basicDeliveryEventArgs.Body);
ThreadPool.QueueUserWorkItem(state =>
{
MessageWork(messageContent);
});
subscription.Ack(basicDeliveryEventArgs);
}
}
public void ReceiveLoop()
{
Console.WriteLine("Waiting receiver starts on thread {0}", Thread.CurrentThread.ManagedThreadId);
IsEnabled = true;
while (IsEnabled)
{
var args = mSubscription.Next();
var message = Encoding.UTF8.GetString(args.Body);
Console.WriteLine(" [x] Received {0} on subscription thread {1}", message, Thread.CurrentThread.ManagedThreadId);
mSubscription.Ack(args);
}
Console.WriteLine("Waiting receiver exits.");
}
private static async Task ReceiveMessagesAsync(SubscribeArguments options)
{
Console.WriteLine($"Connection to RabbitMQ at '{options.RabbitHostName}'");
var factory = new ConnectionFactory {
HostName = options.RabbitHostName
};
using (var connection = factory.CreateConnection())
using (var amqpModel = connection.CreateModel())
{
Console.WriteLine($"Declaring exchange '{options.ExchangeName}' (type={options.ExchangeType})");
amqpModel.ExchangeDeclare(options.ExchangeName, options.ExchangeType, durable: true);
var queueName = amqpModel.QueueDeclare().QueueName;
Console.WriteLine($"Waiting for messages on queue '{queueName}'.");
Console.WriteLine($"Binding to exchange using routing key'{options.RoutingKey}'");
amqpModel.QueueBind(queueName, options.ExchangeName, options.RoutingKey);
Subscription sub = new Subscription(amqpModel, queueName);
while (true)
{
var response = sub.Next(10, out BasicDeliverEventArgs ea);
if (response == false)
{
if (amqpModel.IsClosed)
{
Console.WriteLine("Channel is closed.");
return;
}
continue;
}
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
var routingKey = ea.RoutingKey;
Console.WriteLine($"Received {routingKey}: {message}");
sub.Ack(ea);
await Task.Delay(100);
}
}
}
/// <summary>
/// Poll for messages sent to queue.
/// </summary>
private void Poll()
{
while (Enabled)
{
//Get next message
var deliveryArgs = _subscription.Next();
//Deserialize message
var messageString = Encoding.Default.GetString(deliveryArgs.Body);
var settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto
};
var receivedMessage = JsonConvert.DeserializeObject(messageString, settings);
switch (receivedMessage)
{
case ClientMessage <ChatMessageModel> chatMessageDto:
{
var chatMessage = Mapper.Map <ChatMessage>(chatMessageDto.Model);
// send chat message to view model
Messenger.Default.Send(new NotificationMessage <ChatMessage>(chatMessage, chatMessageDto.OperationType.ToString()), chatMessage.ChatRoomId);
break;
}
case ClientMessage <ChatRoomModel> chatRoomDto:
{
var chatRoom = Mapper.Map <ChatRoom>(chatRoomDto.Model);
Messenger.Default.Send(new NotificationMessage <ChatRoom>(chatRoom, chatRoomDto.OperationType.ToString()));
break;
}
case ClientMessage <UserRoomModel> userDto:
{
var user = Mapper.Map <User>(userDto.Model.User);
Messenger.Default.Send(new NotificationMessage <User>(user, userDto.OperationType.ToString()), userDto.Model.ChatRoom.Id);
break;
}
default:
throw new NotSupportedException("Unsupported message type sent to handler.");
}
// acknowledge message is processed
_subscription.Ack(deliveryArgs);
}
}
public void ProcessMessages()
{
using (_connection = _factory.CreateConnection())
{
using (var channel = _connection.CreateModel())
{
Console.WriteLine("Listening for Topic <payment.purchaseorder>");
Console.WriteLine("------------------------------------------");
Console.WriteLine();
channel.ExchangeDeclare(exchange: ExchangeName, type: "topic");
channel.QueueDeclare(queue: PurchaseOrderQueueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queue: PurchaseOrderQueueName, exchange: ExchangeName, routingKey: "payment.purchaseorder");
//the basic Qos with a prefix count of one.
//This means a consumer will reserve one message after queue to process at a time
//If any of those messages are not acknowledged when they are finished processing, then they will
//be put back onto the queue ready for another consumer to process them
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
//channel.BasicQos(prefetchSize: 0, prefetchCount: 10, global: false);
//Subscription is a high level abstraction that has a more natural iterator feel to it.
//To use it we simply create a new instance and supply the channel
//and the queue which we want to get the messages from.
//noAck: false => consumer will acknowledge when it finishes processing
Subscription subscription = new Subscription(model: channel, queueName: PurchaseOrderQueueName, noAck: false);
while (true) //run an infinite loop to listen to messages in the queue
{
//we enter a while called next and the subscriptions get the next message
BasicDeliverEventArgs deliveryArguments = subscription.Next();
var message = (PurchaseOrder)deliveryArguments.Body.DeSerialize(typeof(PurchaseOrder));
var routingKey = deliveryArguments.RoutingKey;
Console.WriteLine("-- Purchase Order - Routing Key <{0}> : {1}, £{2}, {3}, {4}", routingKey, message.CompanyName, message.AmountToPay, message.PaymentDayTerms, message.PoNumber);
// Once we have finished with the message,we call the ACK method and the subscription
// to acknowledge the message
subscription.Ack(deliveryArguments);
}
}
}
}
public void ProcessMessages()
{
// RabbitMQ Server建立连接
using (_connection = _factory.CreateConnection())
{
using (var channel = _connection.CreateModel())
{
Console.WriteLine($"服务端启动成功，{DateTime.Now}。");
Console.WriteLine("监听 Topic <payment.purchaseorder> 队列");
Console.WriteLine("------------------------------------------");
Console.WriteLine();
channel.ExchangeDeclare(ExchangeName, "topic");
//声明队列以向其发送消息消息
channel.QueueDeclare(PurchaseOrderQueueName, true, false, false, null);
channel.QueueBind(PurchaseOrderQueueName, ExchangeName, "payment.*");
channel.BasicQos(0, 1, false);
Subscription subscription = new Subscription(channel, PurchaseOrderQueueName, false);
while (true)
{
BasicDeliverEventArgs deliveryArguments = subscription.Next();
var routingKey = deliveryArguments.RoutingKey;
if (routingKey == "payment.purchaseorder")
{
var message = (PurchaseOrder)deliveryArguments.Body.DeSerialize(typeof(PurchaseOrder));
Console.WriteLine("-- Purchase Order - Routing Key <{0}> : {1}, ￥{2}, {3}, {4}", routingKey, message.CompanyName, message.AmountToPay, message.PaymentDayTerms, message.PoNumber);
}
if (routingKey == "payment.cardpayment")
{
var message = (CardPayment)deliveryArguments.Body.DeSerialize(typeof(CardPayment));
Console.WriteLine("-- Purchase Card - Routing Key <{0}> : {1}, {2}, ${3}", routingKey, message.Name, message.CardNumber, message.Amount);
}
subscription.Ack(deliveryArguments);
}
}
}
}
