编译工程生产消费

引入依赖

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net5.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <Nullable>enable</Nullable>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <WarningsAsErrors />
    <AnalysisMode>Default</AnalysisMode>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="RabbitMQ.Client" Version="6.2.1" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\Common\Rabbit.Common.csproj" />
  </ItemGroup>
</Project>```

生产消息 

using System.Collections.Immutable;
using System.Drawing;
using System.Threading.Tasks;
using Rabbit.Common.Data.Trades;
using Rabbit.Common.Display;
using RabbitMQ.Client;

namespace Rabbit.Example4.Producer
{
    internal sealed class Program
    {
        private static async Task Main()
        {
            var connectionFactory = new ConnectionFactory
            {
                HostName = "YOUR HOST IP",
                UserName = "YOUR USERNAME",
                Password = "YOUR PASSWORD",
                Port = 5672
            };

            using var connection = connectionFactory.CreateConnection();

            using var channel = connection.CreateModel();

            const string ExchangeName = "dotnet_exchange";
            const string QueueName = "dotnet_queue";

            channel.ExchangeDeclare(
                exchange: ExchangeName,
                type: ExchangeType.Direct,
                durable: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            var queue = channel.QueueDeclare(
                queue: QueueName,
                durable: false,
                exclusive: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            channel.QueueBind(
                queue: queue.QueueName,
                exchange: ExchangeName,
                routingKey: QueueName,
                arguments: ImmutableDictionary<string, object>.Empty);


            while (true)
            {
                var trade = TradeData.GetFakeTrade();

                string routingKey = QueueName;

                channel.BasicPublish(
                    exchange: ExchangeName,
                    routingKey: routingKey,
                    body: trade.ToBytes()
                );

                DisplayInfo<Trade>
                    .For(trade)
                    .SetExchange(ExchangeName)
                    .SetRoutingKey(routingKey)
                    .SetVirtualHost(connectionFactory.VirtualHost)
                    .Display(Color.Cyan);

                await Task.Delay(millisecondsDelay: 3000);
            }
        }
    }
}

消费消息

using System;
using System.Collections.Immutable;
using System.Drawing;
using Rabbit.Common.Data.Trades;
using Rabbit.Common.Display;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;

namespace Rabbit.Example4.Consumer
{
    internal sealed class Program
    {
        private static void Main()
        {
            var connectionFactory = new ConnectionFactory
            {
                HostName = "YOUR HOST IP",
                UserName = "YOUR USER",
                Password = "YOUR PASSWORD",
                Port = 5672
            };

            using var connection = connectionFactory.CreateConnection();
            using var channel = connection.CreateModel();
            
            const string ExchangeName = "dotnet_exchange";
            const string QueueName = "dotnet_queue";

            channel.ExchangeDeclare(
                exchange: ExchangeName,
                type: ExchangeType.Direct,
                durable: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            var queue = channel.QueueDeclare(
                queue: QueueName,
                durable: false,
                exclusive: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            channel.QueueBind(
                queue: queue.QueueName,
                exchange: ExchangeName,
                routingKey: QueueName);

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (sender, eventArgs) =>
            {
                var messageBody = eventArgs.Body.ToArray();
                var trade = Trade.FromBytes(messageBody);

                DisplayInfo<Trade>
                    .For(trade)
                    .SetExchange(eventArgs.Exchange)
                    .SetQueue(queue.QueueName)
                    .SetRoutingKey(eventArgs.RoutingKey)
                    .SetVirtualHost(connectionFactory.VirtualHost)
                    .Display(Color.Yellow);

                channel.BasicAck(eventArgs.DeliveryTag, multiple: false);
            };

            channel.BasicConsume(
                queue: queue.QueueName,
                autoAck: false,
                consumer: consumer);

            Console.ReadLine();
        }
    }
}

ssl生产消息 

using System.Collections.Generic;
using System.Collections.Immutable;
using System.Drawing;
using System.Threading.Tasks;
using Rabbit.Common.Data.Trades;
using Rabbit.Common.Display;
using RabbitMQ.Client;

namespace Rabbit.dotnet.Producer
{
    internal sealed class Program
    {
        private static async Task Main()
        {
            var connectionFactory = new ConnectionFactory
            {
                HostName = "YOUR HOST IP",
                UserName = "YOUR USERNAME",
                Password = "YOUR PASSWORD",
                Port = 5671
            };
            connectionFactory.AuthMechanisms = new List<IAuthMechanismFactory>() { new ExternalMechanismFactory() };
            connectionFactory.Ssl.CertPath = @"D:\tmp\hzmq-test-0520_rabbitmq_ssl_client\client_rabbitmq_key.p12";
            // Ssl.CertPassphrase为固定参数，无需修改
            connectionFactory.Ssl.CertPassphrase = "YOUR PASSPHRASE";
            connectionFactory.Ssl.Enabled = true;
            connectionFactory.Ssl.CertificateValidationCallback = (_, _, _, _) => { return true; };

            using var connection = connectionFactory.CreateConnection();

            using var channel = connection.CreateModel();

            const string ExchangeName = "dotnet_exchange";
            const string QueueName = "dotnet_queue";

            channel.ExchangeDeclare(
                exchange: ExchangeName,
                type: ExchangeType.Direct,
                durable: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            var queue = channel.QueueDeclare(
                queue: QueueName,
                durable: false,
                exclusive: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            channel.QueueBind(
                queue: queue.QueueName,
                exchange: ExchangeName,
                routingKey: QueueName,
                arguments: ImmutableDictionary<string, object>.Empty);

            while (true)
            {
                var trade = TradeData.GetFakeTrade();

                string routingKey = QueueName;

                channel.BasicPublish(
                    exchange: ExchangeName,
                    routingKey: routingKey,
                    body: trade.ToBytes()
                );

                DisplayInfo<Trade>
                    .For(trade)
                    .SetExchange(ExchangeName)
                    .SetRoutingKey(routingKey)
                    .SetVirtualHost(connectionFactory.VirtualHost)
                    .Display(Color.Cyan);

                await Task.Delay(millisecondsDelay: 1000);
            }
        }
    }
}

ssl消费消息

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Drawing;
using Rabbit.Common.Data.Trades;
using Rabbit.Common.Display;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;

namespace Rabbit.example5.Consumer
{
    internal sealed class Program
    {
        private static void Main()
        {
            var connectionFactory = new ConnectionFactory
            {
                HostName = "YOUR HOST IP",
                UserName = "YOUR USERNAME",
                Password = "YOUR PASSWORD",
                Port = 5671
            };
            connectionFactory.AuthMechanisms = new List<IAuthMechanismFactory>() { new ExternalMechanismFactory() };
            connectionFactory.Ssl.CertPath = @"D:\tmp\hzmq-test-0520_rabbitmq_ssl_client\client_rabbitmq_key.p12";
            // Ssl.CertPassphrase为固定参数，无需修改
            connectionFactory.Ssl.CertPassphrase = "YOUR PASSPHRASE";
            connectionFactory.Ssl.Enabled = true;
            connectionFactory.Ssl.CertificateValidationCallback = (_, _, _, _) => { return true; };

            using var connection = connectionFactory.CreateConnection();

            using var channel = connection.CreateModel();

            const string ExchangeName = "dotnet_exchange";
            const string QueueName = "dotnet_queue";

            channel.ExchangeDeclare(
                exchange: ExchangeName,
                type: ExchangeType.Direct,
                durable: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            var queue = channel.QueueDeclare(
                queue: QueueName,
                durable: false,
                exclusive: false,
                autoDelete: false,
                arguments: ImmutableDictionary<string, object>.Empty);

            channel.QueueBind(
                queue: queue.QueueName,
                exchange: ExchangeName,
                routingKey: QueueName);

            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (sender, eventArgs) =>
            {
                var messageBody = eventArgs.Body.ToArray();
                var trade = Trade.FromBytes(messageBody);

                DisplayInfo<Trade>
                    .For(trade)
                    .SetExchange(eventArgs.Exchange)
                    .SetQueue(queue.QueueName)
                    .SetRoutingKey(eventArgs.RoutingKey)
                    .SetVirtualHost(connectionFactory.VirtualHost)
                    .Display(Color.Yellow);

                channel.BasicAck(eventArgs.DeliveryTag, multiple: false);
            };

            channel.BasicConsume(
                queue: queue.QueueName,
                autoAck: false,
                consumer: consumer);

            Console.ReadLine();
        }
    }
}