NanoRabbit 0.1.2

About

NanoRabbit, A Lightweight RabbitMQ .NET 3rd party library for .NET 6 and up, which makes a simple way to manage * Multiple* connections, producers, consumers, and easy to use.

NanoRabbit is under development! Please note that some APIs may change their names or usage!

Building

Branch	Building Status
master
dev

Features

• Customize the name of producers, consumers.
• Dependency injection available.
• Multiple connections, producers, and consumers can be created.

Installation

You can get NanoRabbit by grabbing the latest NuGet package.

See Wiki for more details.

Version

Document

The NanoRabbit Document is at NanoRabbit Wiki.

QuickStart

NanoRabbit is designed as a library depends on NAMING Producers, Consumers. So it's important to set a UNIQUE NAME for each Producers, Consumers.

For more, please visit the Examples.

Create a RabbitProducer && RabbitConsumer

RabbitProducer

Register a RabbitMQ Producer by calling RabbitProducer(), and configure it.

var producer = new RabbitProducer(new[]
{
    new ProducerOptions
    {
        ProducerName = "FooFirstQueueProducer",
        HostName = "localhost",
        Port = 5672,
        UserName = "admin",
        Password = "admin",
        VirtualHost = "FooHost",
        ExchangeName = "amq.topic",
        RoutingKey = "FooFirstKey",
        Type = ExchangeType.Topic,
        Durable = true,
        AutoDelete = false,
        AutomaticRecoveryEnabled = true
    }
});

RabbitConsumer

Register a RabbitMQ Consumer by calling RabbitConsumer(), and configure it.

var consumer = new RabbitConsumer(new[]
{
    new ConsumerOptions
    {
        ConsumerName = "FooSecondQueueConsumer",
        HostName = "localhost",
        Port = 5672,
        UserName = "admin",
        Password = "admin",
        VirtualHost = "FooHost",
        QueueName = "FooSecondQueue",
        AutomaticRecoveryEnabled = true
    }
});

Simple Publish

After creating the RabbitProducer, you can simply publish a message by calling Publish<T>().

producer.Publish<string>("FooFirstQueueProducer", "Hello");

Simple Consume

After creating the RabbitConsumer, you can simply consume a message by inheriting RabbitSubscriber.

public class ConsumeService : RabbitSubscriber
{
    public ConsumeService(IRabbitConsumer consumer, ILogger<RabbitSubscriber>? logger) : base(consumer, logger)
    {
        // ...
    }

    protected override bool HandleMessage(string message)
    {
        // ...
        return true;
    }
}

var consumeService = new ConsumeService(consumer, null, "FooSecondQueueConsumer");

consumeService.StartAsync(CancellationToken.None);

Forward messages

Working on it.

DependencyInjection

AddRabbitProducer

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddRabbitProducer(options =>
{
    options.AddProducer(new ProducerOptions
    {
        ProducerName = "FooFirstQueueProducer",
        HostName = "localhost",
        Port = 5672,
        UserName = "admin",
        Password = "admin",
        VirtualHost = "FooHost",
        ExchangeName = "amq.topic",
        RoutingKey = "FooFirstKey",
        Type = ExchangeType.Topic,
        Durable = true,
        AutoDelete = false,
        Arguments = null,
        AutomaticRecoveryEnabled = true
    });
    options.AddProducer(new ProducerOptions
    {
        ProducerName = "BarFirstQueueProducer",
        HostName = "localhost",
        Port = 5672,
        UserName = "admin",
        Password = "admin",
        VirtualHost = "BarHost",
        ExchangeName = "amq.direct",
        RoutingKey = "BarFirstKey",
        Type = ExchangeType.Direct,
        Durable = true,
        AutoDelete = false,
        Arguments = null,
        AutomaticRecoveryEnabled = true
    });
});

AddRabbitConsumer

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddRabbitConsumer(options =>
{
    options.AddConsumer(new ConsumerOptions
    {
        ConsumerName = "FooFirstQueueConsumer",
        HostName = "localhost",
        Port = 5672,
        UserName = "admin",
        Password = "admin",
        VirtualHost = "FooHost",
        QueueName = "FooFirstQueue",
        AutomaticRecoveryEnabled = true
    });
    options.AddConsumer(new ConsumerOptions
    {
        ConsumerName = "BarFirstQueueConsumer",
        HostName = "localhost",
        Port = 5672,
        UserName = "admin",
        Password = "admin",
        VirtualHost = "BarHost",
        QueueName = "BarFirstQueue", AutomaticRecoveryEnabled = true
    });
});

AddRabbitSubscriber

After adding RabbitConsumer and inheriting RabbitSubscriber, you should register the BackgroundService by AddRabbitSubscriber:

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddRabbitSubscriber<ConsumeService>("FooSecondQueueConsumer");

Using producer or consumer

Then, you can use RabbitProducer and RabbitConsumer at anywhere.

For example:

public class PublishService : BackgroundService
{
    private readonly IRabbitProducer _producer;

    public PublishService(IRabbitProducer producer)
    {
        _producer = producer;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _producer.Publish("FooFirstQueueProducer", "Hello from conn1");
            _producer.Publish("BarFirstQueueProducer", "Hello from conn2");
            await Task.Delay(1000, stoppingToken);
        }
    }
}

More DI Usage at Wiki.

Contributing

1. Fork this repository.
2. Create a new branch in you current repos from the dev branch.
3. Push commits and create a Pull Request (PR) to NanoRabbit.

Todo

• Basic Consume & Publish support
• DependencyInjection support
• Logging support
• Forward messages
• ASP.NET support
• Exchange Configurations
• .NET 7 support
• .NET 8 support
• Caching of failed sends

Thanks

• Visual Studio 2022
• RabbitMQ.Client
• Newtonsoft.Json
• Masstransit
• EasyNetQ

License

NanoRabbit is licensed under the MIT license.