How to Use Azure Service Bus Queue: Simple Guide

To use an Azure Service Bus Queue, create a queue client with your connection string, then send messages using the sender and receive messages using the receiver. This lets you pass messages between applications reliably and asynchronously.

Syntax

Here is the basic syntax to send and receive messages from an Azure Service Bus Queue using the Azure.Messaging.ServiceBus SDK in C#.

• ServiceBusClient: Connects to the Service Bus namespace.
• CreateSender(queueName): Creates a sender to send messages to the queue.
• CreateReceiver(queueName): Creates a receiver to get messages from the queue.
• SendMessageAsync(message): Sends a message.
• ReceiveMessageAsync(): Receives a message.
• CompleteMessageAsync(message): Marks the message as processed.

csharp

var client = new ServiceBusClient(connectionString);
var sender = client.CreateSender(queueName);
await sender.SendMessageAsync(new ServiceBusMessage("Hello"));

var receiver = client.CreateReceiver(queueName);
var message = await receiver.ReceiveMessageAsync();
Console.WriteLine(message.Body.ToString());
await receiver.CompleteMessageAsync(message);

Example

This example shows how to send a message to a queue and then receive it using the Azure Service Bus SDK for .NET.

csharp

using System;
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;

class Program
{
    const string connectionString = "<your_connection_string>";
    const string queueName = "myqueue";

    static async Task Main()
    {
        await SendMessageAsync("Hello, Service Bus!");
        await ReceiveMessageAsync();
    }

    static async Task SendMessageAsync(string messageBody)
    {
        await using var client = new ServiceBusClient(connectionString);
        ServiceBusSender sender = client.CreateSender(queueName);
        ServiceBusMessage message = new ServiceBusMessage(messageBody);
        await sender.SendMessageAsync(message);
        Console.WriteLine($"Sent message: {messageBody}");
    }

    static async Task ReceiveMessageAsync()
    {
        await using var client = new ServiceBusClient(connectionString);
        ServiceBusReceiver receiver = client.CreateReceiver(queueName);
        ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();
        if (receivedMessage != null)
        {
            string body = receivedMessage.Body.ToString();
            Console.WriteLine($"Received message: {body}");
            await receiver.CompleteMessageAsync(receivedMessage);
        }
        else
        {
            Console.WriteLine("No messages available to receive.");
        }
    }
}

Output

Sent message: Hello, Service Bus!
Received message: Hello, Service Bus!

Common Pitfalls

Common mistakes when using Service Bus Queues include:

• Not completing messages after processing, causing them to be redelivered.
• Using the wrong connection string or queue name.
• Not handling null when no messages are available.
• Not disposing clients properly, leading to resource leaks.

Always call CompleteMessageAsync after processing to remove the message from the queue.

csharp

/* Wrong: Not completing message */
var message = await receiver.ReceiveMessageAsync();
Console.WriteLine(message.Body.ToString());
// Missing CompleteMessageAsync call

/* Right: Completing message */
await receiver.CompleteMessageAsync(message);

Quick Reference

Action	Method	Description
Connect to Service Bus	new ServiceBusClient(connectionString)	Creates client to interact with Service Bus.
Create sender	client.CreateSender(queueName)	Prepares to send messages to the queue.
Send message	sender.SendMessageAsync(message)	Sends a message to the queue.
Create receiver	client.CreateReceiver(queueName)	Prepares to receive messages from the queue.
Receive message	receiver.ReceiveMessageAsync()	Gets one message from the queue.
Complete message	receiver.CompleteMessageAsync(message)	Marks message as processed and removes it.

Key Takeaways

Create a ServiceBusClient with your connection string to connect to Azure Service Bus.

Use a sender to send messages and a receiver to receive and complete messages.

Always complete messages after processing to avoid duplicates.

Handle cases where no messages are available to receive.

Dispose clients properly to free resources.