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);
}
static void Main(string[] args)
{
IConnectionFactory factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (IConnection connection = factory.CreateConnection())
using (IModel channel = connection.CreateModel())
{
//We might start the consumer before the publisher
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(" SKO1.HelloWorld.Receiver: {0}", message);
};
//消费者绑定到队列
channel.BasicConsume(
queue: "hello_queue",
noAck: true, //是否不需要消费者手工确认消息
consumer: consumer);
Console.WriteLine(" Press [Enter] to exit...");
Console.ReadLine();
}
}
static void Main(string[] args)
{
var logger = new LoggerConfiguration().MinimumLevel.Verbose().WriteTo.RollingFile(@"E:\C#\Приват\RabbitMQ\Send\Logs\Log-{Date}.txt").WriteTo.ColoredConsole().CreateLogger();
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
logger.Debug("Created new factory {factory}", factory.HostName);
using (var connection = factory.CreateConnection())
{
logger.Debug("Created connection {connection}", connection.ToString());
using (var channel = connection.CreateModel())
{
string queyeName = "first";
channel.QueueDeclare(queyeName, false, false, false, null);
logger.Debug("Created queye {queye}", queyeName);
var consumer = new EventingBasicConsumer(channel);
logger.Debug("Created new consumer {consumer}", consumer.ToString());
consumer.Received += (model, ea) =>
{
var data = ea.Body;
var message = Encoding.UTF8.GetString(data);
logger.Debug("Get messagge from ea.Body {message}", message);
System.Console.WriteLine(message);
};
channel.BasicConsume("first", true, consumer);
System.Console.WriteLine("Type [enter] to exit");
System.Console.ReadLine();
;
}
}
}
public Receiver()
{
ConnectionFactory factory = new ConnectionFactory();
IConnection conn = factory.CreateConnection();
IModel channel = conn.CreateModel();
channel.ExchangeDeclare("processing-limiter", ExchangeType.Fanout);
channel.ExchangeDeclare("text-rank-tasks", ExchangeType.Direct);
string queueName = channel.QueueDeclare().QueueName;
channel.QueueBind(queueName, "processing-limiter", "");
EventingBasicConsumer consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
byte[] body = ea.Body;
string message = Encoding.UTF8.GetString(body);
string[] items = message.Split(':');
if (items.Length == 3 && items[0] == "ProcessingAccepted" && items[2] == "true")
{
channel.BasicPublish(
exchange: "text-rank-tasks",
routingKey: "text-rank-task",
basicProperties: null,
body: Encoding.UTF8.GetBytes("TextRankTask:" + items[1]));
}
};
channel.BasicConsume(queueName, true, consumer);
}
static void Main(string[] args)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: "hello",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null
);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (sender, e) =>
{
var body = e.Body;
var mesage = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received {0}", mesage);
};
channel.BasicConsume(
queue: "hello",
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
}
public void Subscribe()
{
try
{
connection = connf.CreateConnection();
canal = connection.CreateModel();
canal.QueueDeclare(
queue: config.Fila
, durable: true
, exclusive: false
, autoDelete: false
, arguments: null
);
basicConsumer = new EventingBasicConsumer(canal);
basicConsumer.Received += (model, ea) =>
{
var message = Encoding.UTF8.GetString(ea.Body);
//_DataConsumer(new Mensa(Encoding.UTF8.GetString(ea.Body)));
Mensagem mensagem = JsonConvert.DeserializeObject <Mensagem>(message);
_DataConsumer(mensagem);
};
canal.BasicConsume(config.Fila, true, basicConsumer);
canal.CallbackException += canal_CallbackException;
}
catch (BrokerUnreachableException ex)
{
}
catch
{
throw;
}
}
public static void Show()
{
var factory = new ConnectionFactory();
factory.HostName = "localhost"; //RabbitMQ服务在本地运行
factory.UserName = "******"; //用户名
factory.Password = "******"; //密码
using (var connection = factory.CreateConnection())
{
using (IModel channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "DirectExchangeLogAllQueue", durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.ExchangeDeclare(exchange: "DirectExChange", type: ExchangeType.Direct, durable: true, autoDelete: false, arguments: null);
string[] logtypes = new string[] { "debug", "info", "warn", "error" };
foreach (string logtype in logtypes)
{
channel.QueueBind(queue: "DirectExchangeLogAllQueue",
exchange: "DirectExChange",
routingKey: logtype);
}
//消费队列中的所有消息；
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine($"【{message}】，写入文本~~");
};
//处理消息
channel.BasicConsume(queue: "DirectExchangeLogAllQueue",
autoAck: true,
consumer: consumer);
Console.ReadLine();
}
}
}
static void Main(string[] args)
{
var factory = new ConnectionFactory();
factory.Uri = new Uri("amqp://*****:*****@localhost:5672");
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare("emailServiceQueue", true, false, false);
var headers = new Dictionary <string, object>
{
{ "subject", "tour" },
{ "action", "booked" },
{ "x-match", "all" }
};
channel.QueueBind("emailServiceQueue", "webappExchange", "", headers);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (sender, eventArgs) =>
{
var msg = Encoding.UTF8.GetString(eventArgs.Body);
var subject = Encoding.UTF8.GetString(eventArgs.BasicProperties.Headers["subject"] as byte[]);
var action = Encoding.UTF8.GetString(eventArgs.BasicProperties.Headers["action"] as byte[]);
Console.WriteLine($"{subject}.{action}: {msg}");
};
channel.BasicConsume("emailServiceQueue", true, consumer);
Console.ReadLine();
channel.Close();
connection.Close();
}
public string ConsumeMessage()
{
//Apparently, this should not be async.
//The async bit (with Task.Run{ Task.ReturnFrom() })
//should be in the UI thread only.
var factory = new ConnectionFactory()
{
HostName = HostName
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: QueueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
string message = null;
consumer.Received += (model, e) =>
{
message = Encoding.UTF8.GetString(e.Body);
_autoResetEvent.Set();
}; //the callback method, once message finally received.
channel.BasicConsume(
queue: QueueName,
autoAck: true,
consumer: consumer);
_autoResetEvent.WaitOne(); //Wait until message received.
return(message);
}
}
public void Initialize()
{
persistance = new Persistance();
ConnectionFactory factory = new ConnectionFactory()
{
HostName = "localhost"
};
using IConnection connection = factory.CreateConnection();
using IModel channel = connection.CreateModel();
channel.QueueDeclare(queue: JobStatusQueue.QueueName,
durable: JobStatusQueue.Durable,
exclusive: JobStatusQueue.Exclusive,
autoDelete: JobStatusQueue.AutoDelete,
arguments: JobStatusQueue.Arguments);
Console.WriteLine(" [*] Waiting for messages.");
EventingBasicConsumer consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, eventArgs) =>
{
byte[] body = eventArgs.Body.ToArray();
string message = Encoding.UTF8.GetString(body);
Console.WriteLine("[x] Received {0}", message);
SaveJobStatus(message);
};
channel.BasicConsume(
queue: JobStatusQueue.QueueName,
autoAck: true,
consumer: consumer
);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
public RabbitEventSource(
IModel channel,
IEventSerializer eventSerializer,
ILogger log,
string exchangeName,
string exchangeType,
string routingKey)
{
Guard.DebugAssertArgumentNotNull(routingKey, nameof(routingKey));
Guard.DebugAssertArgumentNotNull(exchangeName, nameof(exchangeName));
Guard.DebugAssertArgumentNotNull(exchangeType, nameof(exchangeType));
Guard.DebugAssertArgumentNotNull(eventSerializer, nameof(eventSerializer));
Guard.DebugAssertArgumentNotNull(channel, nameof(channel));
Guard.DebugAssertArgumentNotNull(log, nameof(log));
channel.ExchangeDeclare(exchangeName, exchangeType);
var queueName = $"{exchangeName}-{Guid.NewGuid()}";
var queue = channel.QueueDeclare(queueName);
channel.QueueBind(queue.QueueName, exchangeName, routingKey);
var consumer = new EventingBasicConsumer(channel);
var messageSource = Observable.FromEventPattern <BasicDeliverEventArgs>(
e => consumer.Received += e,
e => consumer.Received -= e);
_deserializedEvents = messageSource
.Select(e => e.EventArgs.Body)
.Select(eventSerializer.Deserialize)
.Do(msg => log.Verbose("{ExchangeName}>>>{Event}", exchangeName, msg))
.Publish();
_eventsConnection = _deserializedEvents.Connect();
channel.BasicConsume(queue.QueueName, true, consumer);
}
private IModel CreateConsumerChannel(string queueName, bool bindConsumer)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var channel = _persistentConnection.CreateModel();
channel.ExchangeDeclare(exchange: BROKER_NAME,
type: "direct");
channel.QueueDeclare(queueName, true, false, false, null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
var eventName = ea.RoutingKey;
await ProcessEvent(eventName, ea.Body, ea.BasicProperties);
channel.BasicAck(ea.DeliveryTag, false);
};
if (bindConsumer)
{
channel.BasicConsume(queue: queueName,
autoAck: false,
consumer: consumer);
}
channel.CallbackException += (sender, ea) =>
{
var key = new Tuple <string, QueueConsumerMode>(queueName, QueueConsumerMode.Normal);
_consumerChannels[key].Dispose();
_consumerChannels[key] = CreateConsumerChannel(queueName, bindConsumer);
};
return(channel);
}
public Task StartAsync(CancellationToken cancellationToken)
{
var factory = new ConnectionFactory
{
UserName = "******",
Password = "******",
VirtualHost = "/",
HostName = "localhost",
Port = 5672
};
_conn = factory.CreateConnection();
var channel = _conn.CreateModel();
//channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
// ... process the message
var msg = Encoding.UTF8.GetString(body);
Console.WriteLine(msg);
//var s = msg.Split('-')[1].ToString();
//Thread.Sleep(int.Parse(s) * 1000);
//channel.BasicAck(ea.DeliveryTag, true);
};
var consumerTag = channel.BasicConsume(queue: "test.queue", autoAck: false, consumerTag: "consumer-test" + new Random().Next(1, 9), consumer: consumer);
return(Task.CompletedTask);
}
public NotificationEventsManager(IServiceScopeFactory serviceScopeFactory,
[FromServices] RabbitMQConfigurations rabbitMQConfiguration,
ILogService logger,
Notifications notificationHub)
{
Console.WriteLine($"{nameof(NotificationEventsManager)} initialized");
_logger = logger;
try
{
_serviceScopeFactory = serviceScopeFactory;
notificationHubInstance = notificationHub;
_factory = new ConnectionFactory()
{
HostName = rabbitMQConfiguration.HostName,
Port = rabbitMQConfiguration.Port,
UserName = rabbitMQConfiguration.UserName,
Password = rabbitMQConfiguration.Password
};
_connection = _factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.QueueDeclare(queue: ApplicationEvents.pushNotificationQueue, durable: true, exclusive: false, autoDelete: false, arguments: null);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += Notification_Received;
_channel.BasicConsume(ApplicationEvents.pushNotificationQueue, true, consumer);
}
catch (Exception ex)
{
_logger.Log(ex.Message, Microsoft.Extensions.Logging.LogLevel.Error, System.Net.HttpStatusCode.InternalServerError, nameof(NotificationEventsManager));
throw ex;
}
}
public static void Main()
{
var factory = new ConnectionFactory();
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "hello",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received {0}", message);
await Task.Yield();
};
channel.BasicConsume(queue: "hello",
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
var cts = new CancellationTokenSource();
Task <int> t = new Task <int>(() => {
Thread.Sleep(5000);
return(1);
}, cts.Token);
t.Start();
}
}
static void Main(string[] args)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
//Trigger The SignalR
Connect().Wait();
channel.QueueDeclare(queue: "Bitcoin",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var data = Encoding.UTF8.GetString(body);
Stoc stoc = JsonConvert.DeserializeObject <Stoc>(data);
Console.WriteLine(" [x] Received {0}", stoc.Name + " : " + stoc.Value);
connectionSignalR.InvokeAsync("PushNotify", stoc);
//-------------------------
};
channel.BasicConsume(queue: "Bitcoin",
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
public static void ConsumeFromDefaultExchange()
{
Console.WriteLine("---------------ConsumeFromDefaultExchange!---------------");
try
{
var factory = new ConnectionFactory();
factory.HostName = "localhost"; //RabbitMQ服务在本地运行
factory.UserName = "******"; //用户名
factory.Password = "******"; //密码
using (var connection = factory.CreateConnection())
{
using (IModel channel = connection.CreateModel())
{
//prefetchSize：预读取的消息内容大小上限(包含)，可以简单理解为消息有效载荷字节数组的最大长度限制，0表示无上限。
//prefetchCount：预读取的消息数量上限，0表示无上限。
//global：false表示prefetchCount单独应用于信道上的每个新消费者，true表示prefetchCount在同一个信道上的消费者共享。
channel.BasicQos(0, 1, false);
//declare consumer
var consumer = new EventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
//binding consumer
channel.BasicConsume("RabbitMqDemo.BasicPublish_test1", true, consumer);
//block thread
Console.WriteLine("press any key to exit.");
Console.ReadLine();
Console.WriteLine("exit.");
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main()
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();
channel.QueueDeclare(queue: "registerUserQueue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body.ToArray();
var message = Encoding.UTF8.GetString(body);
var user = JsonSerializer.Deserialize <User>(message);
Console.WriteLine($"User registered | " +
$"Id:{user.Id} | " +
$"Name:{user.Name} | " +
$"Email:{user.Email} | " +
$"Date created:{user.DateCreated} | " +
$"Date updated:{user.DateUpdated}");
};
channel.BasicConsume(queue: "registerUserQueue",
autoAck: false,
consumer: consumer);
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
static void Main(string[] args)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "exchange_kassa", type: "topic");
channel.QueueDeclare(queue: "queue_planning",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: "queue_planning",
exchange: "exchange_kassa",
routingKey: "guest.checkIn");
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: "queue_planning",
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
public void Receive()
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "direct_logs",
type: "direct");
var queueName = channel.QueueDeclare().QueueName;
channel.QueueBind(queue: queueName,
exchange: "direct_logs",
routingKey: "info");
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(" [x] Received '{0}':'{1}'",
routingKey, message);
};
channel.BasicConsume(queue: queueName,
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
/// <summary>
/// 接收消息(订阅广播)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queue">队列名称</param>
/// <param name="isProperties"></param>
/// <param name="handler">消费处理</param>
/// <param name="isDeadLetter"></param>
public void SubscribeBroadcast <T>(string queue, string exchange, bool isProperties, Action <T> handler, bool isDeadLetter) where T : class
{
//队列声明
var channel = GetModel(queue, exchange, "");
channel.ExchangeDeclare(exchange: exchange, type: ExchangeType.Fanout);
//默认队列,用于广播
var queueName = channel.QueueDeclare().QueueName;
channel.QueueBind(queue: queueName, exchange: exchange, routingKey: "");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = SerializeExtension.DeserializeUtf8(body);
var msg = msgStr.FromJson <T>();
try
{
handler(msg);
}
catch (Exception ex)
{
ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
if (!isDeadLetter)
{
PublishToDead <DeadLetterQueue>(queue, msgStr, ex);
}
}
finally
{
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queueName, false, consumer);
}
/// <summary>
/// 为指定消息队列创建生产者
/// </summary>
/// <param name="channelGuid"></param>
public bool Consume(string channelName, string queueName)
{
ConnectChannel temp = null;
lock (listAccessLock)
{
if (channelList != null)
{
temp = channelList.Where(p => p != null && p.ChannelName == channelName).FirstOrDefault();
}
}
if (temp == null)
{
LogHelper.LogError($"Channel {channelName} Not Exist");
return(false);
}
if (!temp.QueueNames.Contains(queueName))
{
LogHelper.LogError($"Queue {queueName} Not Exist");
return(false);
}
try
{
lock (temp.AccessLock)
{
var consumer = new EventingBasicConsumer(temp.ConsumerChannel);
consumer.Received += Consumer_MultiReceived;
temp.ConsumerChannel.BasicConsume(queueName, false, temp.ChannelGuid, consumer);
}
return(true);
}
catch (Exception e)
{
LogHelper.LogError(e.Message);
return(false);
}
}
public ConfigurationListener(string appName)
{
this._appName = appName.ToLower();
this._configurationSettingList = new List <ConfigurationSetting>();
string hostName = Environment.GetEnvironmentVariable("RabbitMq/Host");
string userName = Environment.GetEnvironmentVariable("RabbitMq/Username");
string passWord = Environment.GetEnvironmentVariable("RabbitMq/Password");
if (hostName == null)
{
_factory = new ConnectionFactory()
{
HostName = "localhost"
};
}
else
{
_factory = new ConnectionFactory()
{
HostName = hostName,
UserName = userName,
Password = passWord
};
}
_connection = _factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.ExchangeDeclare(exchange: _cnstExchangeName, type: _cnstExchangeType);
var queueName = _channel.QueueDeclare().QueueName;
_channel.QueueBind(queue: queueName, exchange: _cnstExchangeName, routingKey: _appName);
_consumer = new EventingBasicConsumer(_channel);
//registering to receive event
_consumer.Received += ReceiveHandler;
_channel.BasicConsume(queue: queueName, autoAck: true, consumer: _consumer);
}
/// <summary>
/// Consulta la información de RabbitMQ
/// </summary>
static void ConsultarRabbitMQ()
{
//Definir las colas por cada tipo de prueba (check)
//Definir el Exhange que hara las veces de Dispatcher (check)
//Establecer los bindings para crear los routingKey (check)
//Primero crear el registro en la base de datos. (check)
//Enviar mensaje a la cola por cada tipo de prueba (check)
//Crear workers capaces de leer mensajes encolados
//Consultar información complementaria de la estrategia al worker
//ejecutar el SCRIPT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
var conn = ConnectionRabbitMQ();
//asumiendo que tenemos la cola, exhange y el routing creado capturamos un mensaje
var channel = conn.CreateModel();
string mensajes = string.Empty;
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
mensajes = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received {0}", mensajes);
};
channel.BasicConsume(queue: "QueueTest2",
autoAck: true,
consumer: consumer);
}
static void Main(string[] args)
{
Console.WriteLine("Queye Name -- " + args[0]);
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.ExchangeDeclare(exchange: "fanout-exch",
type: ExchangeType.Fanout,
durable: false,
autoDelete: false,
arguments: null);
channel.QueueDeclare(args[0], durable: false, exclusive: false, autoDelete: false);
channel.QueueBind(args[0], "fanout-exch", "", null);
var Consumer = new EventingBasicConsumer(channel);
Consumer.Received += (ch, ea) =>
{
var message = Encoding.UTF8.GetString(ea.Body);
Console.WriteLine($"Message Received:{message}");
};
channel.BasicConsume(args[0], true, Consumer);
Console.WriteLine("Waiting for Messages... Press ENTER to Exit");
Console.ReadLine();
channel.Dispose();
connection.Dispose();
}
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", autoAck: false, consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
static void Main(string[] args)
{
Console.WriteLine("CONSUMER APP - 3 !");
var factory = new ConnectionFactory {
HostName = "localhost"
};
// create connection
_connection = factory.CreateConnection();
// create channel
_channel = _connection.CreateModel();
_channel.ExchangeDeclare("Booking.Orders", ExchangeType.Topic, true);
_channel.QueueDeclare("Booking.Cancelled", true, false, false, null);
_channel.QueueBind("Booking.Cancelled", "Booking.Orders", "Booking.Cancelled.*", null);
_channel.BasicQos(0, 1, false);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (ch, ea) =>
{
// received message
var content = System.Text.Encoding.UTF8.GetString(ea.Body);
//When JSON message
//var content = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(ea.Body));
// handle the received message
Console.WriteLine("CONSUMER APP - 3 === " + content.ToString());
_channel.BasicAck(ea.DeliveryTag, false);
};
_channel.BasicConsume("Booking.Cancelled", false, consumer);
}
public void ReceiveFirstAndSecond()
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
{
// Declaração da fila e envio de mensagem
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: "MessageService",
durable: false,
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(message);
Thread.Sleep(10 * 1000);
};
channel.BasicConsume(queue: "MessageService", autoAck: true, consumer: consumer);
Console.WriteLine("Consumer Funcionando");
Console.ReadLine();
}
}
}
public ClientsAPI()
{
ConnectionFactory factory = new ConnectionFactory()
{
UserName = "******", Password = "******", HostName = ""
};
connection = factory.CreateConnection();
channel = connection.CreateModel();
replyQueueName = channel.QueueDeclare().QueueName;
consumer = new EventingBasicConsumer(channel);
props = channel.CreateBasicProperties();
props.ReplyTo = replyQueueName;
channel.BasicConsume(queue: replyQueueName, autoAck: true, consumer: consumer);
consumer.Received += (model, ea) =>
{
Object obtained = ea.Body.Deserializer();
switch (obtained)
{
case JsonClass j:
JsonResponse(System.Text.Encoding.Default.GetString(j.JsonByteArray));
break;
case ImageClass i:
ImageResponse(i.ImageByteArray);
break;
case FileClass f:
FileResponse(f.FileByteArray);
break;
default:
throw new Exception("Type if different! Server sent unknown type!");
}
};
}
public 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: ExchangeType.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.ToArray();
var message = Encoding.UTF8.GetString(body);
Console.WriteLine($" [x] {message}");
};
channel.BasicConsume(
queue: queueName,
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
}
public static int Main(string[] args)
{
Hashtable cnxSettings = new Hashtable();
if (AppConfig.Load(ref cnxSettings) > 0) {
Console.WriteLine( "error occurred while parsing .exe.config.");
}
string queueName = cnxSettings["AMQ_QUEUE"].ToString();
//ServicePointManager.ServerCertificateValidationCallback = ValidateSslCerts;
try {
Console.WriteLine("connecting to Active MQ queue {4} over tcp/{1} on {0} with {2}/{3} credentials",
cnxSettings["AMQ_HOST"].ToString(), cnxSettings["AMQ_PORT"].ToString(), cnxSettings["AMQ_USER"].ToString(),
cnxSettings["AMQ_PASS"].ToString(), cnxSettings["AMQ_QUEUE"].ToString() );
ConnectionFactory factory = new ConnectionFactory();
factory.HostName = cnxSettings["AMQ_HOST"].ToString();
factory.UserName = cnxSettings["AMQ_USER"].ToString();
factory.Password = cnxSettings["AMQ_PASS"].ToString();
factory.VirtualHost = cnxSettings["AMQ_VHOST"].ToString();
factory.Port = Convert.ToInt32(cnxSettings["AMQ_PORT"]);
SslOption sslopts = new SslOption();
sslopts.AcceptablePolicyErrors = SslPolicyErrors.RemoteCertificateNameMismatch |
SslPolicyErrors.RemoteCertificateChainErrors |
SslPolicyErrors.RemoteCertificateNotAvailable;
sslopts.Enabled = true;
sslopts.Version = System.Security.Authentication.SslProtocols.Tls12;
sslopts.ServerName = cnxSettings["AMQ_HOSTNAME"].ToString();
sslopts.CertificateValidationCallback = ValidateSslCerts;
factory.Ssl = sslopts;
// AMQP 0-9-1 Protocol Spec: https://www.rabbitmq.com/resources/specs/amqp0-9-1.pdf
//IProtocol protocol = Protocols.DefaultProtocol;
IProtocol protocol = Protocols.AMQP_0_9_1;
IConnection conn = factory.CreateConnection();
IModel channel = conn.CreateModel();
channel.QueueDeclarePassive(queueName);
Console.WriteLine("connected ...");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) => {
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" * rx: {0}", message);
};
// Disable AutoAcknowledgements. This way a broker will keep items in the queue
channel.BasicConsume(queue: queueName, noAck: true, consumer: consumer);
Console.WriteLine("Press Enter to terminate this channel.");
Console.ReadLine();
conn.Close(200, "Closing the connection");
Console.WriteLine("closing the connection ...");
} catch(Exception e) {
Console.WriteLine(e.Source.ToString() + ": " + e.Message.ToString());
return 1;
}
return 0;
}
