BasicPublishAsync correct use for high performance

[pabermod]

Hi,

I'm migrating to the 7.X version of the library

I'm trying to send messages in a similar way as https://github.com/rabbitmq/rabbitmq-dotnet-client/blob/main/projects/Applications/PublisherConfirms/PublisherConfirms.cs#L110-L171

But also I need to handle the BasicAck taking into account that it can execute with IsMultiple = true

When sending in batch I guess that getting the next sequence publish number will reduce throughput as it needs to do a request via network.

But I need to execute an external handler for each sent message (that is when the BasicAcksAsync). Previously I stored the seq number in a dictionary and when the basic ack arrived if it was multiple I was iterating over the previous sequence number in the dictionary to execute my external handler for the previous messages.

If I execute multiple tasks to send messages and getting the sequence number I can get the same seq. number multiple times right?

    for (int i = 0; i < MESSAGE_COUNT; i++)
    {
        string rk = queueName;
        if (i % 1000 == 0)
        {
            rk = Guid.NewGuid().ToString();
        }
        byte[] body = Encoding.UTF8.GetBytes(i.ToString());

**sequence = await _channel.GetNextPublishSequenceNumberAsync()**
// STORE THE SEQUENCE SOMEWHERE

        publishTasks.Add(channel.BasicPublishAsync(exchange: string.Empty, routingKey: rk, body: body, mandatory: true, basicProperties: props));
        outstandingMessageCount++;

        if (outstandingMessageCount == batchSize)
        {
            foreach (ValueTask pt in publishTasks)
            {
                try
                {
                    await pt;
                }
                catch (PublishException pex)
                {
                    Console.Error.WriteLine($"{DateTime.Now} [ERROR] saw nack or return, pex.IsReturn: '{pex.IsReturn}', seq no: '{pex.PublishSequenceNumber}'");
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine($"{DateTime.Now} [ERROR] saw exception, ex: '{ex}'");
                }
            }
            publishTasks.Clear();
            outstandingMessageCount = 0;
        }
    }

For example with this code, as we are starting multiple tasks, many of them can get the same sequence right?

The only way I see to make it work is to not use the BasicAckAsync as the point where I execute my handler, but do it after awaiting all the tasks. But maybe at this point not all the BasicACKs are yet executed?

Is there any other way I can do this?

Regards

[lukebakken]

I guess that getting the next sequence publish number will reduce throughput as it needs to do a request via network.

No, GetNextPublishSequenceNumberAsync increments a local counter in a thread-safe way. The example code should do what you'd like.

[pabermod]

Thanks I Will test It tomorrow.

Can you also confirm that if I await the basicpublish method It Will wait for the message to be acked? It would seem so as i have seen in mu tests.

This behaviour is different that with the sync client

[lukebakken]

Can you also confirm that if I await the basicpublish method It Will wait for the message to be acked?

Yes, when you have publisher confirmation tracking enabled (which you should) that is the exact behavior!