📢 Publish/Subscribe (Pub/Sub) Pattern

📖 What is Pub/Sub?

The Publish/Subscribe pattern is a messaging design pattern where publishers send messages (events) without knowing who will receive them, and subscribers receive only the messages they are interested in. This decouples producers and consumers, making systems more scalable and flexible.

🛠 Example in .NET Core

Here’s a simple in-memory Pub/Sub implementation in C#:

// Publisher
public class EventPublisher
{
    public delegate void MessageHandler(string message);
    public event MessageHandler OnMessagePublished;

    public void Publish(string message)
    {
        Console.WriteLine($"Publisher: {message}");
        OnMessagePublished?.Invoke(message);
    }
}

// Subscriber
public class EventSubscriber
{
    private readonly string _name;
    public EventSubscriber(string name, EventPublisher publisher)
    {
        _name = name;
        publisher.OnMessagePublished += Receive;
    }

    private void Receive(string message)
    {
        Console.WriteLine($"{_name} received: {message}");
    }
}

// Usage
public class Program
{
    public static void Main()
    {
        var publisher = new EventPublisher();
        var sub1 = new EventSubscriber("Subscriber A", publisher);
        var sub2 = new EventSubscriber("Subscriber B", publisher);

        publisher.Publish("Hello Subscribers!");
    }
}
    

✅ Advantages

• Decouples producers and consumers.
• Supports multiple subscribers for the same event.
• Scales well in distributed systems.
• Improves flexibility and extensibility.

⚠️ Disadvantages

• Harder to trace message flow (debugging complexity).
• Subscribers may process messages at different speeds.
• Requires careful error handling and retries.
• Eventual consistency (not always immediate).

🧭 Best Practices

• Use a message broker (RabbitMQ, Kafka, Azure Service Bus) for production systems.
• Ensure idempotent subscribers to avoid duplicate processing.
• Implement dead-letter queues for failed messages.
• Log and monitor message delivery for observability.

🔒 Precautions

• Secure communication between publishers and subscribers.
• Handle message ordering if required (sessions, partitions).
• Plan for retries and exponential backoff on failures.
• Test under load to ensure stability.

🎯 Summary

The Pub/Sub pattern is a powerful way to build event-driven systems. In .NET Core, it can be implemented in-memory for simple cases or with message brokers like RabbitMQ, Kafka, or Azure Service Bus for enterprise-grade distributed systems.