NSY.MessageBus 1.0.1

NSY.MessageBus

A lightweight RabbitMQ message bus for .NET. Fan-out publish/subscribe with one durable queue per module, IConsumer<T> / ConsumeContext<T>, broker-enforced bounded retry + dead-lettering, and assembly-scanning registration.

Install

dotnet add package NSY.MessageBus

Concepts

• Each message type is published to its own fanout exchange named after the type's full name.
• Each consumer service declares one durable (quorum) queue and binds it to the exchanges of the messages it consumes.
• Failures are nacked with requeue; the queue's x-delivery-limit retries up to MaxRetries, then RabbitMQ routes the message to <queue>.dead.
• Delivery is at-least-once — make consumers idempotent.

Define a message and a consumer

Put message contracts in a shared assembly referenced by both publisher and consumer (the exchange name is the type's FullName, so it must match on both sides).

public record OrderPlaced(Guid OrderId, string Customer, decimal Total);

public class OrderPlacedConsumer : IConsumer<OrderPlaced>
{
    public async Task Consume(ConsumeContext<OrderPlaced> context)
    {
        var order = context.Message;
        // context.CancellationToken, context.MessageId, context.CorrelationId, context.ConversationId
    }
}

Register (single queue)

builder.Services.AddRabbitMqConsumers(
    queueName: "orders-service",
    configureOptions: o =>
    {
        o.HostName = "localhost";
        o.UserName = "guest";
        o.Password = "guest";
        // o.UseTls = true; o.Port = 5671;   // production
        // o.MaxRetries = 5; o.PrefetchCount = 20;
    },
    configureConsumers: c => c.AddConsumer<OrderPlaced, OrderPlacedConsumer>());

Register (bus + a queue per module)

Register the bus once (connection + publisher), then add a queue per module. This keeps publishing working even when a process has no consumers, and isolates each module's consumers to its own queue.

services.AddRabbitMqMessageBus(o => { o.HostName = "..."; /* ... */ });

services.AddRabbitMqConsumerQueue("ShipsHR.Candidates", c =>
{
    c.AddConsumer<CandidateCreated, CandidateCreatedConsumer>();
    // reflection overload for scanning: c.AddConsumer(messageType, consumerType);
});

Publish

Inject IMessagePublisher anywhere:

public class Orders(IMessagePublisher publisher)
{
    public Task Place(OrderPlaced e, CancellationToken ct) => publisher.Publish(e, ct);
}

The exchange is chosen from the message's runtime type, so publishing through a base/interface reference (IIntegratedEvent) still routes to the concrete event's exchange.

Cross-cutting hooks

Implement IConsumeResultHandler (register it yourself) to observe every consume outcome. Handlers are isolated — a throwing handler is logged and never breaks the ack/nack.

Options

Requirements

• .NET 10
• RabbitMQ (quorum queues supported — RabbitMQ 3.8+)