How to set StringProperties in an outgoing messages?

[RamanShuliak-Khazatech]

Here is my service, that create tls1.2 encrypted connection with Artemis and send messages to it:

    public class AmqMessageBrokerService : IAmqMessageBrokerService
    {
        private readonly IBrokerConfigSection brokerConfigSection;
        private readonly IAdditionalHeadersConfigSection additionalHeadersConfigSection;
        private ConnectionFactory connectionFactory;
        private List<Endpoint> endpoints = new List<Endpoint>();
        private ProducerConfiguration producerConfiguration;
        private IConnection connection;
        private IProducer producer;
        private readonly ILoggerService loggerService;

        private bool isConnected = false;

        public AmqMessageBrokerService(
            ILoggerService loggerService)
        {
            this.loggerService = loggerService;

            brokerConfigSection = (IBrokerConfigSection)(ConfigurationManager
                .GetSection("BrokerConfigSection") as NameValueCollection);

            additionalHeadersConfigSection = (IAdditionalHeadersConfigSection)(ConfigurationManager
                .GetSection("AdditionalHeadersConfigSection") as NameValueCollection);

            connectionFactory = new ConnectionFactory()
            {
                SSL =
                {
                    ClientCertificates = null,
                    Protocols = SslProtocols.Tls12,
                    CheckCertificateRevocation = false,
                    RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) =>
                    {
                        return true;
                    },
                    LocalCertificateSelectionCallback = null
                }
            };

            var endpoint = Endpoint.Create(
                host: brokerConfigSection.ArtemisMQHost,
                port: brokerConfigSection.ArtemisMQPort,
                user: brokerConfigSection.ArtemisMQUserName,
                password: brokerConfigSection.ArtemisMQPassword,
                scheme: Scheme.Amqps);

            endpoints.Add(endpoint);

            producerConfiguration = new ProducerConfiguration()
            {
                Address = brokerConfigSection.ArtemisMQAddressName
            };
        }

        public async Task StartSendMessagesToAmqAsync(
            ISyslogReadQueueManageService syslogReadQueueManageService,
            CancellationToken ct)
        {
            while (!ct.IsCancellationRequested)
            {
                Thread.Sleep(1000);

                loggerService.Information("Start connection to ArtemisMq...");

                var timeoutTask = Task.Delay(10000);
                var acceptTask = CreateAmqConnectionAsync();

                await Task.WhenAny(timeoutTask, acceptTask);

                if (!acceptTask.IsCompleted)
                {
                    continue;
                }

                await SendMessageToArtemisAsync(
                    syslogReadQueueManageService,
                    ct);

            }
        }

        private async Task CreateAmqConnectionAsync()
        {
            try
            {
                connection = await connectionFactory.CreateAsync(endpoints);

                producer = await connection.CreateProducerAsync(producerConfiguration);

                isConnected = true;
                loggerService.Information("Установлено соединение с ArtemisMq.");
            }
            catch (Exception ex)
            {
                loggerService.Error($"Error during the connection to Artemis: {ex.Message}");
                isConnected = false;
            }
        }

        private async Task SendMessageToArtemisAsync(
            ISyslogReadQueueManageService syslogReadQueueManageService,
            CancellationToken ct)
        {
            try
            {
                while (!ct.IsCancellationRequested && isConnected)
                {
                    if (syslogReadQueueManageService.TryPeekMessage(out string message)
                        && !String.IsNullOrEmpty(message))
                    {
                        var amqMessage = CreateTextMessage(message);
                        await producer.SendAsync(amqMessage);
                        loggerService.Information($"Message send to Artemis MQ: {message}");
                        syslogReadQueueManageService.TryDequeueMessage(out _);
                    }
                }
            }
            catch (Exception ex)
            {
                loggerService.Error($"Connection with  ArtemisMq interrupted. {ex}. ");
                isConnected = false;
            }
        }

        private Message CreateTextMessage(string message)
        {
            var amqMessage = new Message(message);

            return amqMessage;
        }
    }

Is there any way I can specify in the outgoing message a key-value type StringProperties?

[Havret]

Yes, you're doing it like that:

var amqMessage = new Message(message)
{
    ApplicationProperties =
    {
        ["key"] = "value"
    }
};