public static void ExchangeDeclare(this IModel model, RabbitExchange exchange)
{
model.ExchangeDeclare(
exchange: exchange.ExchangeName,
type: exchange.Type,
durable: exchange.Durable,
autoDelete: exchange.AutoDelete,
arguments: exchange.Arguments);
}
public void Send(RabbitExchange rabbitExchange, RabbitTransportMessage message)
{
using (var channel = _rabbitChannelManager.GetChannel())
{
channel.ExchangeDeclare(rabbitExchange);
var props = channel.CreateBasicProperties();
if (message.Headers != null && message.Headers.Count > 0)
{
props.Headers = message.Headers.ToDictionary(h => h.Key, h => (object)h.Value);
}
channel.BasicPublish(rabbitExchange.ExchangeName, "", props, message.BodyBytes);
}
}
public void StartConsuming(RabbitExchange rabbitExchange, bool autoAck = false)
{
try
{
_channel.ExchangeDeclare(rabbitExchange);
_consumer = new AsyncEventingBasicConsumer(_channel);
_consumer.Received += AsyncDataHandler;
var queue = new RabbitQueue()
{
QueueName = rabbitExchange.ExchangeName + "Queue"
};
_channel.QueueDeclare(queue);
_channel.QueueBind(queue.QueueName, rabbitExchange.ExchangeName, routingKey: "");
_channel.BasicConsume(queue.QueueName, autoAck, _consumer);
}
catch (Exception exception)
{
_logger.LogError("An {@Exception} occured on {ExchangeName} consuming start", exception, rabbitExchange.ExchangeName);
}
}
public RabbitHandler(
IServiceProvider serviceProvider,
RabbitEndpointConfiguration endpointConfiguration,
RabbitExchange exchange,
string queue,
bool durable = true,
bool exclusive = false,
bool autoDelete = false,
bool autoAct = false,
IReadOnlyCollection <string>?routingKeys = null,
IDictionary <string, object>?arguments = null)
{
if (exchange == null)
{
throw new ArgumentException(
$"Message {typeof(TMessage)} not registered in exchange.");
}
if (exchange.Type == RabbitExchangeType.Fanout &&
routingKeys != null &&
routingKeys.Any())
{
throw new ArgumentException(
"Fanout cannot use routing key.");
}
if (string.IsNullOrWhiteSpace(queue))
{
throw new ArgumentException(
"Queue cannot be empty.");
}
var model = endpointConfiguration.Model;
model
.ExchangeDeclare(
exchange.Name,
exchange
.Type
.ToString()
.ToLower(),
exchange.Durable,
exchange.AutoDelete,
exchange.Arguments);
model
.QueueDeclare(
queue,
durable,
exclusive,
autoDelete,
arguments);
if (routingKeys == null ||
!routingKeys.Any())
{
model
.QueueBind(
queue,
exchange.Name,
string.Empty,
arguments);
}
else
{
foreach (var routingKey in routingKeys)
{
model
.QueueBind(
queue,
exchange.Name,
routingKey,
arguments);
}
}
if (!autoAct)
{
model
.BasicQos(
0,
1,
false);
}
var consumer = new AsyncEventingBasicConsumer(
model);
consumer
.Received += async(
obj,
args) =>
{
var message = exchange
.Proto
.BytesToMessage <TMessage, TExchange>(
args.Body);
try
{
var rabbitHandler = serviceProvider
.GetService <TRabbitHandler>();
rabbitHandler
.Receive(
message,
args)
.Wait();
}
catch (Exception e)
{
throw new RabbitMqException(
e.Message,
e);
}
if (!autoAct)
{
model.BasicAck(
args.DeliveryTag,
false);
}
await Task.Yield();
};
model
.BasicConsume(
queue,
autoAct,
consumer);
}
