Why messaging services matter in Azure - Performance Analysis

Time Complexity: Why messaging services matter

O(n)

Understanding Time Complexity

We want to understand how the work done by messaging services grows as more messages are sent.

How does the system handle more messages without slowing down too much?

Scenario Under Consideration

Analyze the time complexity of sending multiple messages to an Azure Service Bus queue.

// Create a Service Bus client
var client = new ServiceBusClient(connectionString);
// Create a sender for the queue
var sender = client.CreateSender(queueName);

// Send messages in a loop
for (int i = 0; i < messageCount; i++) {
    var message = new ServiceBusMessage($"Message {i}");
    await sender.SendMessageAsync(message);
}
    

This code sends a number of messages one by one to a queue in Azure Service Bus.

Identify Repeating Operations

Look at what repeats as the number of messages grows.

• Primary operation: Sending a single message with SendMessageAsync.
• How many times: Exactly once per message, so messageCount times.

How Execution Grows With Input

Each message causes one send operation, so more messages mean more sends.

Input Size (n)	Approx. Api Calls/Operations
10	10 send calls
100	100 send calls
1000	1000 send calls

Pattern observation: The number of send operations grows directly with the number of messages.

Final Time Complexity

Time Complexity: O(n)

This means the work grows in a straight line with the number of messages sent.

Common Mistake

[X] Wrong: "Sending multiple messages at once takes the same time as sending one message."

[OK] Correct: Each message requires its own send operation, so more messages mean more work and more time.

Interview Connect

Understanding how messaging scales helps you design systems that stay responsive as they grow.

Self-Check

"What if we send messages in batches instead of one by one? How would the time complexity change?"