public void PublishBatch <T>(IEnumerable <T> enumerable, PublishOptions options)
{
var activity = MessageDiagnostics.StartMessageOut(options);
try
{
var context = CreateContext <T>(options);
var batch = _model.CreateBasicPublishBatch();
var messages = _serialization.SerializeBatch(enumerable, context.Properties.ContentType);
foreach (var obj in messages)
{
batch.Add(
exchange: context.Exchange,
body: obj,
mandatory: false,
properties: context.Properties,
routingKey: context.RoutingKey
);
}
batch.Publish();
}
finally
{
MessageDiagnostics.StopMessageOut(activity, options);
}
}
public byte[] Serialize <T>(T obj, string?mimeType = null)
{
var activity = MessageDiagnostics.StartMessageSerialize();
var serializer = GetSerializer(mimeType);
var result = serializer.Serialize(obj);
MessageDiagnostics.StopMessageSerialize(activity);
return(result);
}
public T Deserialize <T>(byte[] body, string?mimeType = null)
{
var activity = MessageDiagnostics.StartMessageDeserialize();
var serializer = GetSerializer(mimeType);
var obj = serializer.Deserialize <T>(body);
MessageDiagnostics.StopMessageDeserialize(activity);
return(obj);
}
public List <byte[]> SerializeBatch <T>(IEnumerable <T> enumerable, string?mimeType = null)
{
var activity = MessageDiagnostics.StartMessageSerialize();
var serializer = GetSerializer(mimeType);
var list = new List <byte[]>();
foreach (var item in enumerable)
{
list.Add(serializer.Serialize(item));
}
MessageDiagnostics.StopMessageSerialize(activity);
return(list);
}
public void Publish <T>(T obj, PublishOptions options)
{
var activity = MessageDiagnostics.StartMessageOut(options);
try
{
var context = CreateContext <T>(options);
_model.BasicPublish(
basicProperties: context.Properties,
body: _serialization.Serialize(obj, context.Properties.ContentType),
exchange: context.Exchange,
routingKey: context.RoutingKey
);
}
finally
{
MessageDiagnostics.StopMessageOut(activity, options);
}
}
public ISubscription Subscribe <T>(Func <T, MessageContext, Task> callback, SubscriptionOptions?options = null)
{
var autoAck = options?.AutoAck ?? true;
var exchange = options?.Exchange ?? _config.DefaultExchange;
if (exchange is null)
{
throw new InvalidExchangeException();
}
var model = CreateModel();
EnsureExchangeCreated(model, exchange, options.ExchangeType());
var queueName = EnsureQueueCreated(model, exchange, options?.Queue, options?.RoutingKeys);
var consumer = new AsyncEventingBasicConsumer(model);
var consumerTag = model.BasicConsume(queue: queueName, autoAck: autoAck, consumer: consumer);
consumer.Received += async(_, eventArgs) =>
{
var context = new MessageContext(eventArgs, autoAck, model);
var activity = MessageDiagnostics.StartMessageIn(context);
try
{
var obj = _serialization.Deserialize <T>(eventArgs.Body, eventArgs.BasicProperties.ContentType);
await callback(obj, context);
}
finally
{
MessageDiagnostics.StopMessageIn(activity, context);
}
};
return(new SubscriptionImpl(model, consumerTag));
}
