EzRabbitMq 0.1.1

EzRabbitMq

Easy to use rabbitMq client.

Optional AppInsight consumer/ message / producer tracing.

Optional Logger.

Easy to use features.

Usage

Register services :

services.AddEzRabbitMq(config); // IConfiguration

Configuration

In AppSettings.json file or using environment variables :

{ 
  "EzRabbitMq": {
    "HostName": "localhost",
    "UserName": "guest",
    "Password": "guest",
    "Port": 5672
  }
}

Send direct message

IProducerService producerService; // use injection to get a IProducerService
producerService.Send(new DirectProducerOptions("ROUTING KEY"), new { Example = 123 });

Send topic message

IProducerService producerService; // use injection to get a IProducerService
producerService.Send(new TopicProducerOptions("ROUTING KEY"), new { Example = 123 });

Send fanout message

IProducerService producerService; // use injection to get a IProducerService
producerService.Send(new FanoutProducerOptions(), new { Example = 123 });

Send headers message

IProducerService producerService; // use injection to get a IProducerService
var headerProducer = new HeadersProducerOptions(new()
{
    { "file-type", "jpg" },
    { "theme", "wild" }
});
producerService.Send(headerProducer, new { Example = 123 });

ProducerOptions

Implementation of IProducerOptions are helpers to simplify the producer definition.

E.g.: DirectProducerOptions is defaulting exchangeName to "amq.direct"

public enum DeliveryMode
{
    NonPersistent = 1,
    Persistent = 2 // default value
}

public record ProducerProperties
{
    public byte? Priority { get; set; }

    public string ReplyTo { get; set; }

    public TimeSpan? Expiration { get; set; }

    private PublicationAddress? ReplyToAddress { get; set; }

    public Dictionary<string, string> Headers { get; set; } = new ();

    public DeliveryMode DeliveryMode { get; set; } = DeliveryMode.Persistent;
}

public interface IProducerOptions
{
    string RoutingKey { get; }
    string ExchangeName { get; }
    
    ProducerProperties Properties { get; }
}

Listen messages using events

You can create EventMailbox mailbox instance and react to messages with the OnMessageReceived event.

// use injection to get a IMailboxService
var mailboxOptions = new DirectMailboxOptions("ROUTING KEY", "MAILBOX NAME");
var mailbox = mailboxService.Create<EventMailbox<DataSample>>(mailboxOptions, new ConsumerOptions());

mailbox.OnMessageReceived += (sender, data) => {
    // data is IMessage<DataSample>
};

Listen direct messages

// use injection to get a IMailboxService
var mailboxOptions = new DirectMailboxOptions("ROUTING KEY", "MAILBOX NAME");
var mailbox = mailboxService.Create<EventMailbox<DataSample>>(mailboxOptions, new ConsumerOptions());

Listen topic messages

// use injection to get a IMailboxService
var mailboxOptions = new TopicMailboxOptions("ROOT.SECTOR-A.*", "MAILBOX NAME");
var mailbox = mailboxService.Create<EventMailbox<DataSample>>(mailboxOptions, new ConsumerOptions());

Listen fanout messages

// use injection to get a IMailboxService
var mailboxOptions = new FanoutMailboxOptions("MAILBOX NAME");
var mailbox = mailboxService.Create<EventMailbox<DataSample>>(mailboxOptions, new ConsumerOptions());

Listen headers messages

// use injection to get a IMailboxService
var converterToGifMailboxOptions = new HeadersMailboxOptions(new()
{
    { "type", "jpg" },
    { "type", "png" }
}, XMatch.Any, "converter-to-gif");
var converterToGifMailbox = mailboxService.Create<EventMailbox<DataSample>>(converterToGifMailboxOptions, new ConsumerOptions());

var thumbnailCreatorMailboxOptions = new HeadersMailboxOptions(new()
{
    { "type", "gif" },
    { "target", "avatar" }
}, XMatch.All, "thumbnail-creator");
var thumbnailCreatorMailbox = mailboxService.Create<EventMailbox<DataSample>>(thumbnailCreatorMailboxOptions, new ConsumerOptions());

Listen messages using implementation

Or you can implement your own Mailbox inheriting Mailbox<T>, you will have to implement the OnMessage method.

public class MyMailbox<T> : Mailbox<T>
{
    public EventMailbox(
        ILogger<MyMailbox<T>> logger,
        IMailboxOptions options,
        ISessionService session,
        ConsumerOptions consumerOptions
    ) : base(logger, options, null, session, consumerOptions)   { }

    protected override void OnMessage(IMessage<T> data)
    {
        // react to message
    }
}

// use injection to get a IMailboxService
var options = ConsumerOptions.CreateDefaultOptions;
var mailboxOptions = new DirectMailboxOptions("ROUTINg KEY", "MAILBOX NAME");
var mailbox = mailboxService.Create<MyMailbox<DataSample>>(mailboxOptions, options);

MailboxOptions

You can create you own MailboxOptions inheriting IMailboxOptions :

public enum ExchangeTypes
{
    Direct,
    Topic,
    Fanout,
    Headers
}

public interface IMailboxOptions
{
    public string ExchangeName { get; }

    public ExchangeTypes ExchangeType { get; }

    public string RoutingKey { get; }

    public string QueueName { get; }
    
    public Dictionary<string, string> Headers { get; }
}

ConsumerOptions

This options can add rabbitMq arguments to enable / disable features.

ConsumerOptions default values:

var options = new ConsumerOptions
{
    AutoAck = true, // if AutoAck is false EzRabbit is gonna ack message only if no exception occured
    QueueDurable = false, // set durable feature on queue (need queue recreation if changed)
    QueueAutoDelete = false. // set auto delete feature on queue (need queue recreation if changed)
    QueueExclusive  = false, // set exclusive feature on queue (need queue recreation if changed)
    QueueSizeLimit = 0,  // set the queue size limit (need queued recreation)
    ExchangeDurable = true, // set durable feature on exchange (need exchange recreation if changed)
    ExchangeAutoDelete = false, // set auto delete feature on exchange (need exchange recreation if changed)
    AckMultiple = false,
    PrefetchLimit = 0,
    PrefetchCount = 0, // set the prefetch amount of message read by this consumer
    PrefetchGlobal = true,
    // (on autoAck false and RequeueOnException false, exception will be considered as dead letter)
    RequeueOnException = false,
    DeadLetterExchangeName = null, // (string) set the DeadLetterExchangeName 
    DeadLetterRoutingKey = null, // (string) set the routing Key for dead letter
    RetryCount = 0, // After 3 retry exception in the message will be reject,
    QueueDeclareArguments = new Dictionary<string, object>(),
    QueueBindArguments = new Dictionary<string, object>(),
    ExchangeDeclareArguments = new Dictionary<string, object>()
};