Azure 服务总线队列入门 (.NET)

在本快速入门中,你将执行以下步骤:

  1. 使用 Azure 门户创建服务总线命名空间。
  2. 使用 Azure 门户创建服务总线队列。
  3. 编写 .NET Core 控制台应用程序,向队列发送一组消息。
  4. 编写 .NET Core 控制台应用程序,从队列接收这些消息。

注意

本快速入门分步介绍了如何实施一个简单方案,将一批消息发送到服务总线队列并接收这些消息。 有关其他和高级方案的更多示例,请参阅 GitHub 上的服务总线 .NET 示例

先决条件

如果你是首次使用该服务,请在使用本快速入门之前先参阅服务总线概述

  • Azure 订阅。 若要使用 Azure 服务(包括 Azure 服务总线),需要一个订阅。 如果没有现有的 Azure 帐户,可以注册试用订阅
  • Microsoft Visual Studio 2019。 Azure 服务总线客户端库利用 C# 8.0 中引入的新功能。 你仍可使用以前的 C# 语言版本的库,但新语法将不可用。 若要使用完整语法,建议使用 .NET Core SDK 3.0 或更高版本进行编译,并将语言版本设置为 latest。 如果使用 Visual Studio,Visual Studio 2019 以前的版本与生成 C# 8.0 项目时所需的工具将不兼容。

在 Azure 门户中创建命名空间

若要开始在 Azure 中使用服务总线消息实体,必须先使用在 Azure 中唯一的名称创建一个命名空间。 命名空间提供了用于对应用程序中的 Service Bus 资源进行寻址的范围容器。

创建命名空间:

  1. 登录到 Azure 门户

  2. 在门户的左侧导航窗格中,依次选择“+ 创建资源”、“集成”、“服务总线” 。

    Image showing selection of Create a resource, Integration, and then Service Bus in the menu.

  3. 在“创建命名空间”页的“基本信息”标记中,执行以下步骤 :

    1. 对于“订阅”,请选择要在其中创建命名空间的 Azure 订阅。

    2. 对于“资源组”,请选择该命名空间驻留到的现有资源组,或创建一个新资源组。

    3. 输入命名空间的名称。 命名空间名称应遵循以下命名约定:

      • 该名称在 Azure 中必须唯一。 系统会立即检查该名称是否可用。
      • 名称长度最少为 6 个字符,最多为 50 个字符。
      • 名称只能包含字母、数字和连字符“-”。
      • 名称必须以字母开头,并且必须以字母或数字结尾。
      • 名称不以“-sb”或“-mgmt”结尾。
    4. 对于“位置”,请选择托管该命名空间的区域。

    5. 对于“定价层”,请选择命名空间的定价层(“基本”、“标准”或“高级”)。 对于本快速入门,请选择“标准”。

      若要使用主题和订阅,请选择“标准”或“高级”。 基本定价层不支持主题/订阅。

      如果选择了“高级”定价层,请指定“消息传送单元”数 。 高级层在 CPU 和内存级别提供资源隔离,使每个工作负荷在隔离的环境中运行。 此资源容器称为消息传送单元。 高级命名空间至少具有一个消息传送单元。 可为每个服务总线高级命名空间选择 1、2 或 4 个消息传送单元。 有关详细信息,请参阅服务总线高级消息传送

    6. 选择“查看 + 创建” 。 系统现已创建命名空间并已将其启用。 可能需要等待几分钟,因为系统将为帐户配置资源。

      Image showing the Create a namespace page

    7. 在“查看 + 创建”页上,查看设置,然后选择“创建” 。

  4. 在“部署”页上选择“转到资源”。

    Image showing the deployment succeeded page with the Go to resource link.

  5. 将会看到服务总线命名空间的主页。

    Image showing the home page of the Service Bus namespace created.

获取连接字符串

创建新的命名空间会自动生成一个初始共享访问签名 (SAS) 策略,该策略包含主密钥和辅助密钥以及主要连接字符串和辅助连接字符串,每个连接字符串都授予对命名空间所有方面的完全控制权。 请参阅服务总线身份验证和授权,了解如何创建规则来对普通发送者和接收者的权限进行更多限制。

若要复制命名空间的主要连接字符串,请执行以下步骤:

  1. 在“服务总线命名空间”页中的左侧菜单上,选择“共享访问策略” 。

  2. 在“共享访问策略”页,选择“RootManageSharedAccessKey” 。

    Screenshot shows the Shared access policies window with a policy highlighted.

  3. 在“策略: RootManageSharedAccessKey”窗口中,单击“主连接字符串”旁边的复制按钮,将连接字符串复制到剪贴板供稍后使用 。 将此值粘贴到记事本或其他某个临时位置。

    Screenshot shows an S A S policy called RootManageSharedAccessKey, which includes keys and connection strings.

    可使用此页面复制主密钥、辅助密钥和辅助连接字符串。

在 Azure 门户中创建队列

  1. 在“服务总线命名空间”页面上,选择左侧导航菜单中的“队列”

  2. 在“队列”页面上,选择工具栏上的“+ 队列”

  3. 输入队列名称,其他值则保留默认值。

  4. 现在选择“创建”。

    Image showing creation of a queue in the portal

将消息发送到队列

本部分介绍如何创建一个向服务总线队列发送消息的 .NET Core 控制台应用程序。

注意

本快速入门分步介绍了如何实施一个简单方案,将一批消息发送到服务总线队列并接收这些消息。 有关其他和高级方案的更多示例,请参阅 GitHub 上的服务总线 .NET 示例

创建控制台应用程序

  1. 启动 Visual Studio 2019。

  2. 选择“创建新项目”。

  3. 在“创建新项目”对话框中执行以下步骤:如果看不到此对话框,请在菜单中选择“文件”,然后依次选择“新建”、“项目”。

    1. 选择“C#”作为编程语言。

    2. 选择“控制台”作为应用程序类型。

    3. 从结果列表中选择“控制台应用程序”。

    4. 然后,选择“下一步” 。

      Image showing the Create a new project dialog box with C# and Console selected

  4. 输入 QueueSender 作为项目名称,输入 ServiceBusQueueQuickStart 作为解决方案名称,然后选择下一步

    Image showing the solution and project names in the Configure your new project dialog box

  5. 在“其他信息”页面,选择“创建”来创建解决方案和项目。

添加服务总线 NuGet 包

  1. 在菜单中选择“工具”>“NuGet 包管理器”>“包管理器控制台”

  2. 运行以下命令安装 Azure.Messaging.ServiceBus NuGet 包:

    Install-Package Azure.Messaging.ServiceBus
    

添加将消息发送到队列的代码

  1. 在 Program.cs 中,将以下 using 语句添加到命名空间定义顶部,位于类声明之前。

    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
  2. Program 类中的 Main 方法前声明以下属性。

    <NAMESPACE CONNECTION STRING> 替换为服务总线命名空间的主连接字符串。 并将 <QUEUE NAME> 替换为你的队列的名称。

    
    // connection string to your Service Bus namespace
    static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
    // name of your Service Bus queue
    static string queueName = "<QUEUE NAME>";
    
    // the client that owns the connection and can be used to create senders and receivers
    static ServiceBusClient client;
    
    // the sender used to publish messages to the queue
    static ServiceBusSender sender;
    
    // number of messages to be sent to the queue
    private const int numOfMessages = 3;
    
    
  3. Main 方法中的代码替换为以下代码。 请查看代码注释了解代码的详细信息。 下面是代码中的重要步骤。

    1. 使用命名空间的主连接字符串创建 ServiceBusClient 对象。

    2. ServiceBusClient 对象调用 CreateSender 方法,从而为特定的“服务总线”队列创建 ServiceBusSender 对象。

    3. 使用 ServiceBusSender.CreateMessageBatchAsync 方法创建 ServiceBusMessageBatch 对象。

    4. 使用 ServiceBusMessageBatch.TryAddMessage 将消息添加到该批次。

    5. 使用 ServiceBusSender.SendMessagesAsync 方法将批量消息发送到“服务总线”队列。

      static async Task Main()
      {
          // 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.
          //
          // Create the clients that we'll use for sending and processing messages.
          client = new ServiceBusClient(connectionString);
          sender = client.CreateSender(queueName);
      
          // 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();
      }    
      
  4. Program.cs 文件应如下所示:

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
    namespace QueueSender
    {
        class Program
        {
            // connection string to your Service Bus namespace
            static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
            // name of your Service Bus queue
            static string queueName = "<QUEUE NAME>";
    
            // the client that owns the connection and can be used to create senders and receivers
            static ServiceBusClient client;
    
            // the sender used to publish messages to the queue
            static ServiceBusSender sender;
    
            // number of messages to be sent to the queue
            private const int numOfMessages = 3;
    
            static async Task Main()
            {
                // 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.
                //
                // Create the clients that we'll use for sending and processing messages.
                client = new ServiceBusClient(connectionString);
                sender = client.CreateSender(queueName);
    
                // 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();
            }
        }
    }   
    
  5. <NAMESPACE CONNECTION STRING> 替换为服务总线命名空间的主连接字符串。 并将 <QUEUE NAME> 替换为你的队列的名称。

  6. 生成项目并确保没有错误。

  7. 运行程序并等待出现确认消息。

    A batch of 3 messages has been published to the queue
    
  8. 在 Azure 门户中按照以下步骤操作:

    1. 导航到服务总线命名空间。

    2. 在“概述”页上,在底部中间的窗格中选择队列。

      Image showing the Service Bus Namespace page in the Azure portal with the queue selected.

    3. 请注意“必备”部分中的值。

    Image showing the number of messages received and the size of the queue

    请注意以下值:

    • 队列的活动消息计数值现在为 3。 每次运行此发件人应用而不检索消息时,该值会增加 3。
    • 每次应用向队列添加消息时,队列的当前大小都会递增。
    • 消息图表中的底部指标部分中,可以看到队列有三条传入的消息。

从队列接收消息

在本节中,你将会创建一个 .NET Core 控制台应用,用于接收来自队列的消息。

注意

本快速入门分步介绍了如何实施一个简单方案,将一批消息发送到服务总线队列并接收这些消息。 有关其他和高级方案的更多示例,请参阅 GitHub 上的服务总线 .NET 示例

为接收器创建项目

  1. 在“解决方案资源管理器”窗口中,右键单击 ServiceBusQueueQuickStart 解决方案,指向添加,然后选择新建项目
  2. 选择控制台应用程序,然后选择下一步
  3. 输入 QueueReceiver 作为项目名称,然后选择创建
  4. 解决方案资源管理器窗口中,右键单击 QueueReceiver,然后选择设为启动项目

添加服务总线 NuGet 包

  1. 在菜单中选择“工具”>“NuGet 包管理器”>“包管理器控制台”

  2. 程序包管理器控制台窗口中,确认 QueueReceiver 选定用于默认项目。 如果不是,请使用下拉列表选择 QueueReceiver

    Screenshot showing QueueReceiver project selected in the Package Manager Console

  3. 运行以下命令安装 Azure.Messaging.ServiceBus NuGet 包:

    Install-Package Azure.Messaging.ServiceBus
    

添加从队列接收消息的代码

在本部分中,你将添加从队列检索消息的代码。

  1. 在 Program.cs 中,将以下 using 语句添加到命名空间定义顶部,位于类声明之前。

    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
  2. Program 类中的 Main 方法前声明以下属性。

    <NAMESPACE CONNECTION STRING> 替换为服务总线命名空间的主连接字符串。 并将 <QUEUE NAME> 替换为你的队列的名称。

    // connection string to your Service Bus namespace
    static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
    // name of your Service Bus queue
    static string queueName = "<QUEUE NAME>";
    
    // the client that owns the connection and can be used to create senders and receivers
    static ServiceBusClient client;
    
    // the processor that reads and processes messages from the queue
    static ServiceBusProcessor processor;
    
  3. 将以下方法添加到 Program 类中,来处理接收到的消息和任何错误。

    // handle received messages
    static 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
    static Task ErrorHandler(ProcessErrorEventArgs args)
    {
        Console.WriteLine(args.Exception.ToString());
        return Task.CompletedTask;
    }
    
  4. Main 方法中的代码替换为以下代码。 请查看代码注释了解代码的详细信息。 下面是代码中的重要步骤。

    1. 使用命名空间的主连接字符串创建 ServiceBusClient 对象。

    2. ServiceBusClient 对象调用 CreateProcessor 方法,从而为指定的“服务总线”队列创建 ServiceBusProcessor 对象。

    3. ServiceBusProcessor 对象的 ProcessMessageAsyncProcessErrorAsync 事件指定处理程序。

    4. 通过对 ServiceBusProcessor 对象调用 StartProcessingAsync 以开始处理消息。

    5. 当用户按下某个键结束处理时,将对 ServiceBusProcessor 对象调用 StopProcessingAsync

      有关更多信息,请参阅代码注释。

      static async Task Main()
      {
          // 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.
          //
      
          // Create the client object that will be used to create sender and receiver objects
          client = new ServiceBusClient(connectionString);
      
          // create a processor that we can use to process the messages
          processor = client.CreateProcessor(queueName, 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();
          }
      }
      
  5. Program.cs 应如下所示:

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
    namespace QueueReceiver
    {
        class Program
        {
            // connection string to your Service Bus namespace
            static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
            // name of your Service Bus queue
            static string queueName = "<QUEUE NAME>";
    
            // the client that owns the connection and can be used to create senders and receivers
            static ServiceBusClient client;
    
            // the processor that reads and processes messages from the queue
            static ServiceBusProcessor processor;
    
            // handle received messages
            static async Task MessageHandler(ProcessMessageEventArgs args)
            {
                string body = args.Message.Body.ToString();
                Console.WriteLine($"Received: {body}");
    
                // complete the message. messages is deleted from the queue. 
                await args.CompleteMessageAsync(args.Message);
            }
    
            // handle any errors when receiving messages
            static Task ErrorHandler(ProcessErrorEventArgs args)
            {
                Console.WriteLine(args.Exception.ToString());
                return Task.CompletedTask;
            }
    
            static async Task Main()
            {
                // 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.
                //
    
                // Create the client object that will be used to create sender and receiver objects
                client = new ServiceBusClient(connectionString);
    
                // create a processor that we can use to process the messages
                processor = client.CreateProcessor(queueName, 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();
                }
            }
        }
    }
    
  6. <NAMESPACE CONNECTION STRING> 替换为服务总线命名空间的主连接字符串。 并将 <QUEUE NAME> 替换为你的队列的名称。

  7. 生成项目并确保没有错误。

  8. 运行接收器应用程序。 你应该会看到接收的消息。 按任意键来停止使用接收器和应用程序。

    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
    
  9. 再次检查门户。 等待几分钟,如果未看到活动消息的 0,请刷新页面。

    • 活动消息计数和当前大小值现为 0

    • 在“消息”图表底部的“指标”部分中,可以看到队列有三条传入消息和三条传出消息 。

      Active messages and size after receive

后续步骤

请参阅以下文档和示例: