C#与C++交互开辟系列（二十一）：跨历程通信之利用RabbitMQ实现消息队列通 ...

1. 媒介

在分布式系统或跨语言系统中，消息队列是一种广泛利用的办理方案，用于在差别系统或步伐之间实现异步通信。本文将探讨怎样利用 RabbitMQ 在 C# 和 C++ 步伐之间实现跨历程通信。RabbitMQ 是一种高效、可靠的消息代理，支持多种语言客户端，包罗 C# 和 C++，能够资助我们在两个差别的历程间通报数据。
2. 什么是 RabbitMQ？

RabbitMQ 是一个基于 AMQP（高级消息队列协议）的开源消息代理。它可以在差别的应用步伐或服务之间通报消息，通过队列解耦系统中的发送方和吸收方，使得异步处理和分布式架构的实现更加简朴。
特点：

• 提供可靠的消息传输。
  
• 支持多种语言客户端。
  
• 支持队列持久化。
  
• 支持消息确认和重试机制。
  

3. 实现 C# 和 C++ 间的通信流程

为了实现 C# 和 C++ 之间的通信，我们将利用 RabbitMQ 消息队列。以下是团体步调：

• 设置 RabbitMQ 服务器：确保已安装并设置 RabbitMQ 服务器。
  
• 利用 C++ 发送消息：C++ 步伐将连接到 RabbitMQ 并发送一条消息到指定的队列。
  
• 利用 C# 吸收消息：C# 步伐将连接到同一 RabbitMQ 队列并吸收消息。
  

4. 环境准备

• 安装 RabbitMQ：确保 RabbitMQ 服务器已安装并在本地或长途运行。
  
• 安装客户端库：
  
  
  
  • C++：利用 RabbitMQ C++ 客户端库。
    
  • C#：利用 RabbitMQ.Client NuGet 包。
    
  
  

5. 编码实现：利用 RabbitMQ 进行 C# 和 C++ 间的跨历程通信

1. C++ 代码：发送和吸收消息

联合我们前面的文章 C++开辟基础之利用librabbitmq库实现RabbitMQ消息队列通信。在C++ 步伐利用 RabbitMQ 客户端库发送消息。
2. C# 代码：发送和吸收消息

C#发送消息的示例

C#发送端实现将消息发送到 RabbitMQ 服务器，并通过指定的交换机进行路由：

• 设置连接：设置 RabbitMQ 服务器地址 (localhost)、端口（5672）、交换机名称 (example_exchange)、路由键 (example_key) 和消息内容。
  
• 创建连接与频道：通过 ConnectionFactory 创建连接和通信频道。
  
• 声明交换机：通过 channel.ExchangeDeclare 声明一个 direct 范例的交换机，确保交换机存在。
  
• 发送消息：将消息转换为字节数组并利用 channel.BasicPublish 将消息发送到指定的交换机，利用指定的路由键进行路由。
  
• 输出日记：控制台打印发送的消息内容。
  

1. using RabbitMQ.Client;
2. using System.Text;
4. namespace MQCSharpApp
5. {
6.     internal class Program
7.     {
8.         static void Main(string[] args)
9.         {
10.             // 连接RabbitMQ服务器的配置
11.             string hostname = "localhost";  // RabbitMQ 服务器地址
12.             int port = 5672;  // RabbitMQ 默认端口
13.             string exchange = "example_exchange";  // 交换机名称
14.             string routingKey = "example_key";  // 路由键
16.             // 创建连接工厂并设置连接参数
17.             var factory = new ConnectionFactory() { HostName = hostname, Port = port };
19.             using (var connection = factory.CreateConnection())
20.             using (var channel = connection.CreateModel())
21.             {
22.                 // 声明一个交换机（确保交换机已经存在，类型为direct）
23.                 channel.ExchangeDeclare(exchange, ExchangeType.Direct);
24.                 int messageCount = 1;
25.                 // 定时发送消息
26.                 Timer timer = new Timer((e) =>
27.                 {
28.                     // 准备消息内容
29.                     string message = $"Hello from C#！ Message number: {messageCount++}";
30.                     var body = Encoding.UTF8.GetBytes(message);
32.                     // 发布消息到交换机
33.                     channel.BasicPublish(exchange: exchange,
34.                                          routingKey: routingKey,
35.                                          basicProperties: null,
36.                                          body: body);
38.                     Console.WriteLine($" [x] Sent: {message}");
39.                 }, null, 0, 1000); // 每隔 1 秒发送一次
40.                 Console.WriteLine("Press [enter] to exit.");
41.                 Console.ReadLine();  // 保持程序运行直到按下 Enter
42.             }
43.         }
44.     }
45. }

复制代码

实行步调和运行结果：

• 启动 C++ 步伐：实行 C++ 步伐，使其在交换机 example_exchange 上监听消息。
  
• 运行 C# 步伐：实行 C# 步伐，定时发送一条消息到 RabbitMQ 队列。
  
• C++ 步伐收到来自C#步伐发送的消息，并在控制台中显示。
  

C# 吸收消息的示例

C#创建吸收端：

• 创建连接和频道：与发送者的步伐类似，创建了一个连接工厂，连接到 RabbitMQ 服务器，并建立一个频道。
  
• 声明交换机：与发送者一致，声明确一个范例为 direct 的交换机。
  
• 声明队列：在消费者端声明确一个队列（example_queue）。如果队列已经存在，它不会重新创建。
  
• 队列与交换机绑定：通过 QueueBind 将队列与交换机绑定，利用 routingKey 来进行消息路由。
  
• 事故消费者：创建了一个 EventingBasicConsumer 来吸收消息。当有消息到达时，consumer.Received 事故会被触发，消息内容会被打印到控制台。
  
• 开始消费消息：通过 BasicConsume 启动消息的消费，这会让步伐进入等候吸收消息的状态，直到按下 Ctrl+C 停止。
  

1. using RabbitMQ.Client;
2. using RabbitMQ.Client.Events;
3. using System;
4. using System.Text;
6. namespace MQCSharpApp
7. {
8.     internal class Program
9.     {
10.         static void Main(string[] args)
11.         {
12.             // 连接RabbitMQ服务器的配置
13.             string hostname = "localhost";  // RabbitMQ 服务器地址
14.             int port = 5672;  // RabbitMQ 默认端口
15.             string exchange = "example_exchange";  // 交换机名称
16.             string routingKey = "example_key";  // 路由键
17.             string queueName = "example_queue";  // 队列名称
19.             // 创建连接工厂并设置连接参数
20.             var factory = new ConnectionFactory() { HostName = hostname, Port = port };
22.             using (var connection = factory.CreateConnection())
23.             using (var channel = connection.CreateModel())
24.             {
25.                 // 声明一个交换机（确保交换机已经存在，类型为direct）
26.                 channel.ExchangeDeclare(exchange, ExchangeType.Direct);
28.                 // 声明一个队列，并确保队列存在
29.                 channel.QueueDeclare(queue: queueName,
30.                                      durable: false,
31.                                      exclusive: false,
32.                                      autoDelete: false,
33.                                      arguments: null);
35.                 // 将队列与交换机绑定
36.                 channel.QueueBind(queue: queueName,
37.                                    exchange: exchange,
38.                                    routingKey: routingKey);
40.                 Console.WriteLine(" [*] Waiting for messages. To exit press [CTRL+C]");
42.                 // 创建一个事件消费者来接收消息
43.                 var consumer = new EventingBasicConsumer(channel);
44.                 consumer.Received += (model, ea) =>
45.                 {
46.                     var body = ea.Body.ToArray();
47.                     var message = Encoding.UTF8.GetString(body);
48.                     Console.WriteLine($" [x] Received: {message}");
49.                 };
51.                 // 开始消费消息
52.                 channel.BasicConsume(queue: queueName,
53.                                      autoAck: true,  // 自动确认消息
54.                                      consumer: consumer);
56.                 // 保持程序运行，直到按下 CTRL+C
57.                 Console.ReadLine();
58.             }
59.         }
60.     }
61. }

复制代码

实行步调和运行结果：

• 启动 C# 步伐： 实行 C# 步伐，使其在交换机 example_exchange 上监听消息。
  
• 运行 C++步伐：实行 C++ 步伐，定时发送一条消息到 RabbitMQ 队列。
  
• C#步伐收到来自 C++步伐的消息，并在控制台中显示。
  
  
  
  

6. C# 和 C++ 跨历程通信的机制分析

上风

• 解耦：消息队列解耦了消息的发送方和吸收方，使得两者可以独立开辟、摆设和运行。
  
• 异步通信：消息队列允许异步通信，发送方不必要等候吸收方的响应。
  
• 跨语言支持：RabbitMQ 提供了多种语言客户端，适用于多语言环境中的通信需求。
  

7. 适用场景

• 异步使命：比如日记处理、异步盘算等使命，发送方将使命消息发送到队列，吸收方从队列中读取并处理使命。
  
• 分布式系统通信：在差别服务之间实现消息通报和事故驱动。
  
• 使命队列：多个消费者从同一队列读取消息进行负载均衡。
  

8. 总结

本文介绍了怎样利用 RabbitMQ 实现 C# 和 C++ 之间的跨历程通信，通过消息队列通报消息。这种方式非常适用于异步、跨语言的通信需求。RabbitMQ 为消息的可靠传输提供了保障，并支持消息的持久化。
在下一篇文章中，我们将探讨怎样利用 WebApi 实现 C# 和 C++ 之间的直接通信，以及其在性能和复杂性方面的差异。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。