C# : Implementing Redis Pub/Sub Message Broker - Order processing example

Redis in distributed system memory

In distributed systems, communication between components is essential for real-time data processing and coordination. Redis Pub/Sub (Publisher/Subscriber) provides a lightweight and efficient mechanism for message broadcasting and consumption. In this blog post, we'll explore how to implement Redis Pub/Sub as a message broker in C# applications, enabling seamless communication between different parts of the system.

1. Setting Up Redis Server: Before implementing Redis Pub/Sub in C#, ensure you have a Redis server up and running. You can install Redis locally or use a cloud-based Redis service provider like Azure Redis Cache or AWS ElastiCache.

2. Installing Redis Client Library: To interact with Redis from a C# application, you'll need to install a Redis client library. One popular choice is StackExchange.Redis, a high-performance Redis client library for .NET.

dotnet add package StackExchange.Redis

3. Publisher Implementation: The publisher component in your application is responsible for publishing messages to specific channels in Redis.

using StackExchange.Redis;

public class RedisPublisher
{
    private readonly ConnectionMultiplexer _redis;
    private readonly ISubscriber _subscriber;

    public RedisPublisher(string connectionString)
    {
        _redis = ConnectionMultiplexer.Connect(connectionString);
        _subscriber = _redis.GetSubscriber();
    }

    public void PublishMessage(string channel, string message)
    {
        _subscriber.Publish(channel, message);
    }
}

4. Subscriber Implementation: The subscriber component listens for messages on specific channels and performs actions accordingly.

using StackExchange.Redis;

public class RedisSubscriber
{
    private readonly ConnectionMultiplexer _redis;
    private readonly ISubscriber _subscriber;

    public RedisSubscriber(string connectionString)
    {
        _redis = ConnectionMultiplexer.Connect(connectionString);
        _subscriber = _redis.GetSubscriber();
    }

    public void SubscribeToChannel(string channel, Action<RedisChannel, RedisValue> handler)
    {
        _subscriber.Subscribe(channel, handler);
    }
}

5. Usage Example: Let's see how we can use the Redis Pub/Sub components in a C# application.

// Publisher
var publisher = new RedisPublisher("localhost");
publisher.PublishMessage("channelName", "Hello from Publisher!");

// Subscriber
var subscriber = new RedisSubscriber("localhost");
subscriber.SubscribeToChannel("channelName", (channel, message) =>
{
    Console.WriteLine($"Received message on channel {channel}: {message}");
});

Let's, implement an order processing system using Redis Pub/Sub as a message broker in a C# application. Redis Pub/Sub will facilitate communication between the order submission component and the order processing component, ensuring seamless processing of orders in real-time.

Order Submission Component: This component is responsible for submitting new orders to the system. We'll publish orders to a Redis channel named "new_orders".

using StackExchange.Redis;

public class OrderSubmitter
{
    private readonly ConnectionMultiplexer _redis;
    private readonly ISubscriber _subscriber;

    public OrderSubmitter(string connectionString)
    {
        _redis = ConnectionMultiplexer.Connect(connectionString);
        _subscriber = _redis.GetSubscriber();
    }

    public void SubmitOrder(Order order)
    {
        var message = JsonConvert.SerializeObject(order);
        _subscriber.Publish("new_orders", message);
    }
}

Order Processing Component: This component listens for new orders on the "new_orders" channel and processes them accordingly.

using StackExchange.Redis;

public class OrderProcessor
{
    private readonly ConnectionMultiplexer _redis;
    private readonly ISubscriber _subscriber;

    public OrderProcessor(string connectionString)
    {
        _redis = ConnectionMultiplexer.Connect(connectionString);
        _subscriber = _redis.GetSubscriber();
    }

    public void StartProcessingOrders()
    {
        _subscriber.Subscribe("new_orders", (channel, message) =>
        {
            var order = JsonConvert.DeserializeObject<Order>(message);
            ProcessOrder(order);
        });
    }

    private void ProcessOrder(Order order)
    {
        // Process the order (e.g., validate, update inventory, send confirmation)
        Console.WriteLine($"Processing order: {order.OrderId}");
    }
}

Usage Example: Let's see how to use the order submission and processing components in a C# application.

// Order submission
var submitter = new OrderSubmitter("localhost");
var order = new Order { OrderId = 123, CustomerId = 456, TotalAmount = 100 };
submitter.SubmitOrder(order);

// Order processing
var processor = new OrderProcessor("localhost");
processor.StartProcessingOrders();

Conclusion: By leveraging Redis Pub/Sub in a C# application, we've implemented an efficient order processing system where new orders are submitted and processed in real-time. The publisher-subscriber model provided by Redis Pub/Sub ensures seamless communication between different parts of the system, enabling scalable and responsive order processing workflows. Whether it's handling incoming orders, updating inventory, or sending order confirmations, Redis Pub/Sub serves as a powerful tool for building event-driven architectures in C# applications.