📬 RabbitMQ in .NET Core

📖 What is RabbitMQ?

RabbitMQ is an open-source message broker that implements the AMQP (Advanced Message Queuing Protocol). It enables asynchronous communication between services, decoupling producers (senders) and consumers (receivers).

🛠 Example in .NET Core

Below is a simple example of publishing and consuming messages using RabbitMQ in a .NET Core application.

// Install-Package RabbitMQ.Client

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

public class RabbitMQExample
{
    public static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };

        // Publisher
        using (var connection = factory.CreateConnection())
        using (var channel = connection.CreateModel())
        {
            channel.QueueDeclare(queue: "demo-queue",
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);

            string message = "Hello from .NET Core!";
            var body = Encoding.UTF8.GetBytes(message);

            channel.BasicPublish(exchange: "",
                                 routingKey: "demo-queue",
                                 basicProperties: null,
                                 body: body);

            Console.WriteLine($" [x] Sent {message}");
        }

        // Consumer
        using (var connection = factory.CreateConnection())
        using (var channel = connection.CreateModel())
        {
            channel.QueueDeclare(queue: "demo-queue",
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine($" [x] Received {message}");
            };
            channel.BasicConsume(queue: "demo-queue",
                                 autoAck: true,
                                 consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
            Console.ReadLine();
        }
    }
}
    

✅ Advantages

• Decouples services for better scalability.
• Supports multiple messaging patterns (pub/sub, work queues, RPC).
• Reliable delivery with acknowledgments and persistence.
• Cross-platform and supports multiple protocols.

⚠️ Disadvantages

• Requires setup and maintenance of RabbitMQ server.
• Performance overhead compared to direct communication.
• Eventual consistency (messages may not be processed instantly).
• Learning curve for advanced features (exchanges, routing, clustering).

🧭 Best Practices

• Use durable queues and persistent messages for reliability.
• Implement acknowledgments to avoid message loss.
• Use dead-letter exchanges for failed messages.
• Design consumers to be idempotent (safe to process messages multiple times).
• Monitor queues and set alerts for backlog growth.

🔒 Precautions

• Secure RabbitMQ with authentication, TLS, and proper access control.
• Handle network failures and retries gracefully.
• Do not overload queues with very large messages (use storage + references instead).
• Test system under load to ensure stability.

🎯 Summary

RabbitMQ is a powerful and flexible message broker that helps build scalable, decoupled, and resilient distributed systems in .NET Core. With proper design, monitoring, and security, it can handle high-throughput enterprise workloads effectively.