Implementing Publish-Subscribe with Service Bus Topics and Subscriptions

1. Topics and Subscriptions: The Core Concepts

In the pub/sub pattern, the producer (or publisher) sends a message to a topic. The topic then forwards the message to one or more subscriptions. You can think of a subscription as a virtual queue that gets a copy of every message sent to the topic. Each subscription can have its own consumer, allowing different parts of your system to react to the same event independently.

For a concise explanation of how topics differ from the queues we used in the last lesson, the following video segment is very helpful.

2. Setting Up the Azure Resources

Just like in our last lesson, we need to create our resources in Azure before we can write code. We can reuse the same Service Bus namespace. Inside it, you'll need to create a topic and at least one subscription for that topic.

Crucially, a subscription will only receive messages that are published after the subscription has been created.

You can use the Microsoft Learn quickstart to walk through these steps.

3. Implementing the Publisher and Subscriber

With your strong background in .NET and your experience from the last lesson, you'll find the code for topics and subscriptions feels very familiar. We'll use the same Azure.Messaging.ServiceBus library.

The Publisher

The publisher's role is to send a message to the topic. The key point here is that the publisher is completely unaware of the subscriptions; it only needs to know the topic's name.

The code is nearly identical to the queue sender from our last lesson. The only change is that you provide a topic name instead of a queue name when creating the ServiceBusSender.

The Subscriber

The subscriber's role is to listen for messages on a specific subscription. We will again use the ServiceBusProcessor for a robust, background-processing implementation.

The primary difference from our queue receiver is that when you create the ServiceBusProcessor, you must provide both the topic name and the subscription name.

Let's implement this. We'll use the official quickstart, which provides a clean, self-contained example.

4. Advanced Routing with Subscription Filters

The real power of the pub/sub pattern emerges when you use filters. By default, each subscription gets a copy of every message. Filters allow a subscription to declare which messages it's interested in, enabling sophisticated routing scenarios.

There are two main types of filters:

• SqlRuleFilter: Evaluates a SQL-like expression against the message's system and user properties. This provides powerful and flexible filtering logic.
• CorrelationRuleFilter: A highly optimized filter that performs simple equality matching on properties like CorrelationId, Subject, ReplyTo, and user properties.

Let's see how to apply these.

Hands-On Exercise: Implementing Filters

Now, let's put this knowledge into practice.

1. Create New Subscriptions: In the Azure Portal, go to your topic and create two new subscriptions:

   • HighPriorityOrders
   • BlueOrders

2. Add Filters:

   • Select the HighPriorityOrders subscription, go to its Filters section, delete the default 1=1 filter, and add a new Correlation Filter. Set the CorrelationId property to high.
   • Select the BlueOrders subscription, go to its Filters, delete the default filter, and add a new SQL Filter. Set the filter expression to color = 'blue'.

3. Modify the Publisher: Update your publisher application (Program.cs) to send a few different types of messages. The key is to set the ApplicationProperties and CorrelationId on the ServiceBusMessage object.

   // Inside your publisher's main method, before the finally block
   
   // Create a client and sender
   var client = new ServiceBusClient("YOUR_CONNECTION_STRING");
   var sender = client.CreateSender("YOUR_TOPIC_NAME");
   
   // Message 1: High-priority blue order
   var msg1 = new ServiceBusMessage("High-priority blue order")
   {
       CorrelationId = "high"
   };
   msg1.ApplicationProperties.Add("color", "blue");
   msg1.ApplicationProperties.Add("quantity", 10);
   
   // Message 2: Low-priority blue order
   var msg2 = new ServiceBusMessage("Low-priority blue order")
   {
       CorrelationId = "low"
   };
   msg2.ApplicationProperties.Add("color", "blue");
   msg2.ApplicationProperties.Add("quantity", 5);
   
   // Message 3: High-priority red order
   var msg3 = new ServiceBusMessage("High-priority red order")
   {
       CorrelationId = "high"
   };
   msg3.ApplicationProperties.Add("color", "red");
   msg3.ApplicationProperties.Add("quantity", 8);
   
   await sender.SendMessageAsync(msg1);
   await sender.SendMessageAsync(msg2);
   await sender.SendMessageAsync(msg3);
   
   Console.WriteLine("Sent 3 messages with properties.");
   
   await sender.DisposeAsync();
   await client.DisposeAsync();
   

4. Test the Subscribers:

   • Modify your subscriber application to read from the HighPriorityOrders subscription. Run it. It should receive Message 1 and Message 3.
   • Modify it again to read from the BlueOrders subscription. Run it. It should receive Message 1 and Message 2.
   • Finally, modify it to read from your original subscription (which has no filter). It should receive all three messages.

This exercise demonstrates how a single publisher can send events to a topic, and multiple, independent downstream services can selectively process only the events relevant to them.

Conclusion

In this lesson, you've moved beyond simple point-to-point messaging and implemented the powerful publish-subscribe pattern. This is a fundamental building block for creating scalable, decoupled, and event-driven applications in Azure.

Here are the key takeaways:

• Pub/Sub Pattern: A topic acts as a message broker, fanning out messages to multiple independent subscriptions.
• .NET SDK Consistency: Sending to a topic and receiving from a subscription uses the same core ServiceBusClient, ServiceBusSender, and ServiceBusProcessor classes you're already familiar with, making the transition from queues straightforward.
• Publisher Decoupling: The message publisher sends to a topic and has no knowledge of the consumers.
• Subscription Filtering: SqlRuleFilter and CorrelationRuleFilter are essential tools for routing messages to the appropriate subscribers based on message properties, enabling advanced architectural patterns.

In our next lesson, we will shift gears to explore Azure's other primary messaging service. We will implement basic queueing operations using Azure Queue Storage, and by comparing it with what we've learned about Service Bus, you'll gain a clear understanding of when to use each service.