Quickstart: Send and receive messages from an Azure Service Bus queue (.NET)

In this quickstart, you do the following steps:

1. Create a Service Bus namespace, using the Azure portal.

2. Create a Service Bus queue, using the Azure portal.

3. Write a .NET console application to send a set of messages to the queue.

4. Write a .NET console application to receive those messages from the queue.

   This quickstart provides step-by-step instructions to implement a simple scenario of sending a batch of messages to a Service Bus queue and then receiving them. For an overview of the .NET client library, see Azure Service Bus client library for .NET. For more samples, see Service Bus .NET samples on GitHub.

If you're new to the service, see Service Bus overview before you do this quickstart.

• Azure subscription. To use Azure services, including Azure Service Bus, you need a subscription. If you don't have an existing Azure account, you can sign up for a trial subscription.
• Visual Studio 2022. The sample application makes use of new features that were introduced in C# 10. You can still use the Service Bus client library with previous C# language versions, but the syntax might vary. To use the latest syntax, we recommend that you install .NET 6.0, or higher and set the language version to latest. If you're using Visual Studio, versions before Visual Studio 2022 aren't compatible with the tools needed to build C# 10 projects.

To begin using Service Bus messaging entities in Azure, you must first create a namespace with a name that is unique across Azure. A namespace provides a scoping container for Service Bus resources (queues, topics, etc.) within your application.

To create a namespace:

1. Sign in to the Azure portal.

2. Navigate to the All services page.

3. On the left navigation bar, select Integration from the list of categories, hover the mouse over Service Bus, and then select + button on the Service Bus tile.

   

4. In the Basics tag of the Create namespace page, follow these steps:

   1. For Subscription, choose an Azure subscription in which to create the namespace.

   2. For Resource group, choose an existing resource group, or create a new one.

   3. Enter a name for the namespace. The namespace name should adhere to the following naming conventions:

      • The name must be unique across Azure. The system immediately checks to see if the name is available.
      • The name length is at least 6 and at most 50 characters.
      • The name can contain only letters, numbers, hyphens -.
      • The name must start with a letter and end with a letter or number.
      • The name doesn't end with -sb or -mgmt.

   4. For Location, choose the region in which your namespace should be hosted.

   5. For Pricing tier, select the pricing tier (Basic, Standard, or Premium) for the namespace. For this quickstart, select Standard.

      Important

      If you want to use topics and subscriptions, choose either Standard or Premium. Topics/subscriptions aren't supported in the Basic pricing tier.

      If you selected the Premium pricing tier, specify the number of messaging units. The premium tier provides resource isolation at the CPU and memory level so that each workload runs in isolation. This resource container is called a messaging unit. A premium namespace has at least one messaging unit. You can select 1, 2, 4, 8 or 16 messaging units for each Service Bus Premium namespace. For more information, see Service Bus Premium Messaging.

   6. Select Review + create at the bottom of the page.

      

   7. On the Review + create page, review settings, and select Create.

5. Once the deployment of the resource is successful, select Go to resource on the deployment page.

   

6. You see the home page for your service bus namespace.

   

1. On the Service Bus Namespace page, expand Entities on the navigational menu to the left, and select Queues.

2. On the Queues page, select + Queue on the toolbar.

3. Enter a name for the queue, and leave the other values with their defaults.

4. Now, select Create.

   

This quick start shows you two ways of connecting to Azure Service Bus: passwordless and connection string. The first option shows you how to use your security principal in Azure Active Directory and role-based access control (RBAC) to connect to a Service Bus namespace. You don't need to worry about having hard-coded connection string in your code or in a configuration file or in a secure storage like Azure Key Vault. The second option shows you how to use a connection string to connect to a Service Bus namespace. If you are new to Azure, you may find the connection string option easier to follow. We recommend using the passwordless option in real-world applications and production environments. For more information, see Authentication and authorization. You can also read more about passwordless authentication on the overview page.

This section shows you how to create a .NET console application to send messages to a Service Bus queue.

1. In Visual Studio, select File -> New -> Project menu.

2. On the Create a new project dialog box, do the following steps: If you don't see this dialog box, select File on the menu, select New, and then select Project.

   1. Select C# for the programming language.

   2. Select Console for the type of the application.

   3. Select Console App from the results list.

   4. Then, select Next.

      

3. Enter QueueSender for the project name, ServiceBusQueueQuickStart for the solution name, and then select Next.

   

4. On the Additional information page, select Create to create the solution and the project.

1. Replace the contents of Program.cs with the following code. The important steps are outlined in the following section, with additional information in the code comments.

   • Passwordless
   • Connection string

   • Creates a ServiceBusClient object using the connection string.
   • Invokes the CreateSender method on the ServiceBusClient object to create a ServiceBusSender object for the specific Service Bus queue.
   • Creates a ServiceBusMessageBatch object by using the ServiceBusSender.CreateMessageBatchAsync method.
   • Add messages to the batch using the ServiceBusMessageBatch.TryAddMessage.
   • Sends the batch of messages to the Service Bus queue using the ServiceBusSender.SendMessagesAsync method.

   Important

   Update placeholder values (<NAMESPACE-CONNECTION-STRING> and <QUEUE-NAME>) in the code snippet with names of your Service Bus namespace and queue.

   using Azure.Messaging.ServiceBus;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the sender used to publish messages to the queue
   ServiceBusSender sender;
   
   // number of messages to be sent to the queue
   const int numOfMessages = 3;
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // set the transport type to AmqpWebSockets so that the ServiceBusClient uses the port 443. 
   // If you use the default AmqpTcp, you will need to make sure that the ports 5671 and 5672 are open
   
   // TODO: Replace the <NAMESPACE-CONNECTION-STRING> and <QUEUE-NAME> placeholders
   var clientOptions = new ServiceBusClientOptions()
   { 
       TransportType = ServiceBusTransportType.AmqpWebSockets
   };
   client = new ServiceBusClient("<NAMESPACE-CONNECTION-STRING>", clientOptions);
   sender = client.CreateSender("<QUEUE-NAME>");
   
   // create a batch 
   using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
   
   for (int i = 1; i <= numOfMessages; i++)
   {
       // try adding a message to the batch
       if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
       {
           // if it is too large for the batch
           throw new Exception($"The message {i} is too large to fit in the batch.");
       }
   }
   
   try
   {
       // Use the producer client to send the batch of messages to the Service Bus queue
       await sender.SendMessagesAsync(messageBatch);
       Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await sender.DisposeAsync();
       await client.DisposeAsync();
   }
   
   Console.WriteLine("Press any key to end the application");
   Console.ReadKey();
   

2. Build the project, and ensure that there are no errors.

3. Run the program and wait for the confirmation message.

   A batch of 3 messages has been published to the queue
   

   Important

   In most cases, it takes a minute or two for the role assignment to propagate in Azure. In rare cases, it might take up to eight minutes. If you receive authentication errors when you first run your code, wait a few moments and try again.

4. In the Azure portal, follow these steps:

   1. Navigate to your Service Bus namespace.

   2. On the Overview page, select the queue in the bottom-middle pane.

      

   3. Notice the values in the Settings section.

      

   Notice the following values:

   • The Active message count value for the queue is now 3. Each time you run this sender app without retrieving the messages, this value increases by 3.
   • The current size of the queue increments each time the app adds messages to the queue.
   • In the Messages chart in the bottom Metrics section, you can see that there are three incoming messages for the queue.

In this section, you create a .NET console application that receives messages from the queue.

1. In the Solution Explorer window, right-click the ServiceBusQueueQuickStart solution, point to Add, and select New Project.
2. Select Console application, and select Next.
3. Enter QueueReceiver for the Project name, and select Create.
4. In the Solution Explorer window, right-click QueueReceiver, and select Set as a Startup Project.

In this section, you add code to retrieve messages from the queue.

1. Within the Program class, add the following code:

   • Passwordless
   • Connection string

   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the queue
   ServiceBusProcessor processor;
   

2. Append the following methods to the end of the Program class.

   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body}");
   
       // complete the message. message is deleted from the queue. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   

3. Append the following code to the end of the Program class. The important steps are outlined in the following section, with additional information in the code comments.

   • Passwordless
   • Connection string

   • Creates a ServiceBusClient object using the connection string.
   • Invokes the CreateProcessor method on the ServiceBusClient object to create a ServiceBusProcessor object for the specified Service Bus queue.
   • Specifies handlers for the ProcessMessageAsync and ProcessErrorAsync events of the ServiceBusProcessor object.
   • Starts processing messages by invoking the StartProcessingAsync on the ServiceBusProcessor object.
   • When user presses a key to end the processing, invokes the StopProcessingAsync on the ServiceBusProcessor object.

   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Set the transport type to AmqpWebSockets so that the ServiceBusClient uses port 443. 
   // If you use the default AmqpTcp, make sure that ports 5671 and 5672 are open.
   
   // TODO: Replace the <NAMESPACE-CONNECTION-STRING> and <QUEUE-NAME> placeholders
   var clientOptions = new ServiceBusClientOptions()
   {
       TransportType = ServiceBusTransportType.AmqpWebSockets
   };
   client = new ServiceBusClient("<NAMESPACE-CONNECTION-STRING>", clientOptions);
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <QUEUE-NAME> placeholder
   processor = client.CreateProcessor("<QUEUE-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // add handler to process messages
       processor.ProcessMessageAsync += MessageHandler;
   
       // add handler to process any errors
       processor.ProcessErrorAsync += ErrorHandler;
   
       // start processing 
       await processor.StartProcessingAsync();
   
       Console.WriteLine("Wait for a minute and then press any key to end the processing");
       Console.ReadKey();
   
       // stop processing 
       Console.WriteLine("\nStopping the receiver...");
       await processor.StopProcessingAsync();
       Console.WriteLine("Stopped receiving messages");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   

4. The completed Program class should match the following code:

   • Passwordless
   • Connection string

   using Azure.Messaging.ServiceBus;
   using System;
   using System.Threading.Tasks;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the queue
   ServiceBusProcessor processor;
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Set the transport type to AmqpWebSockets so that the ServiceBusClient uses port 443. 
   // If you use the default AmqpTcp, make sure that ports 5671 and 5672 are open.
   
   // TODO: Replace the <NAMESPACE-CONNECTION-STRING> and <QUEUE-NAME> placeholders
   var clientOptions = new ServiceBusClientOptions()
   {
       TransportType = ServiceBusTransportType.AmqpWebSockets
   };
   client = new ServiceBusClient("<NAMESPACE-CONNECTION-STRING>", clientOptions);
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <QUEUE-NAME> placeholder
   processor = client.CreateProcessor("<QUEUE-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // add handler to process messages
       processor.ProcessMessageAsync += MessageHandler;
   
       // add handler to process any errors
       processor.ProcessErrorAsync += ErrorHandler;
   
       // start processing 
       await processor.StartProcessingAsync();
   
       Console.WriteLine("Wait for a minute and then press any key to end the processing");
       Console.ReadKey();
   
       // stop processing 
       Console.WriteLine("\nStopping the receiver...");
       await processor.StopProcessingAsync();
       Console.WriteLine("Stopped receiving messages");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   
   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body}");
   
       // complete the message. message is deleted from the queue. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   

5. Build the project, and ensure that there are no errors.

6. Run the receiver application. You should see the received messages. Press any key to stop the receiver and the application.

   Wait for a minute and then press any key to end the processing
   Received: Message 1
   Received: Message 2
   Received: Message 3
   
   Stopping the receiver...
   Stopped receiving messages
   

7. Check the portal again. Wait for a few minutes and refresh the page if you don't see 0 for Active messages.

   • The Active message count and Current size values are now 0.

   • In the Messages chart in the bottom Metrics section, you can see that there are three incoming messages and three outgoing messages for the queue.

     

See the following documentation and samples:

• Azure Service Bus client library for .NET - Readme
• Samples on GitHub
• .NET API reference
• Abstract away infrastructure concerns with higher-level frameworks like NServiceBus

Navigate to your Service Bus namespace in the Azure portal, and select Delete on the Azure portal to delete the namespace and the queue in it.

See Get started with Azure Service Bus topics and subscriptions (.NET).