Links

Description

It is a message broker with message queues and publish-subscribe topics.

Name	Description
Queue	Allows for Sending and Receiving of messages. Often used for point-to-point communication.
Topic	As opposed to Queues, Topics are better suited to publish/subscribe scenarios. A topic can be sent to, but requires a subscription, of which there can be multiple in parallel, to consume from.
Subscription	The mechanism to consume from a Topic. Each subscription is independent, and receives a copy of each message sent to the topic. Rules and Filters can be used to tailor which messages are received by a specific subscription.

Erreur lors de la création de la vignette : /bin/bash: /usr/bin/convert: No such file or directory Error code: 127

Configure the service bus on Azure

Azure portal → Service Bus → Add
Create namespace: the namespace will be the url use by the service bus [namespace].servicebus.windows.net
Pricing tiers: Basic, Standard (Topics), Premium (private network, dedicated capacity)
Once deployed, go to the newly create service bus namespace
- add queue
- add topic then add subscription

Sender

Add Nuget package Azure.Messaging.ServiceBus

Program.cs

private const string ConnectionString = "get it from Azure Portal → Service Bus Namespace → Shared access policy → Primary Connection String";
private const string QueueName = "queue1";
private const string TopicName = "topic1";

static async Task Main(string[] args)
{
    var client = new ServiceBusClient(ConnectionString);
    try  // use await using in C# 8 / .Net Core
    {
        var sender = client.CreateSender(QueueName);
        var sender = client.CreateSender(TopicName);

        var message = new ServiceBusMessage("Hello!");
        await sender.SendMessageAsync(message);
        Console.WriteLine($"Sent {message.Body}");
    }
    finally
    {
        await client.DisposeAsync();
    }
}

Receiver

Add Nuget package Azure.Messaging.ServiceBus

1 receiver for 1 subscription.

Program.cs

private const string ConnectionString = "get it from Azure Portal → Service Bus Namespace → Shared access policy → Primary Connection String";
private const string QueueName = "queue1";
private const string SubscriptionName = "subscription1";

static async Task Main(string[] args)
{
    var client = new ServiceBusClient(ConnectionString);
    var processor = client.CreateProcessor(QueueName);
    var processor = client.CreateProcessor(TopicName, SubscriptionName);

    try
    {
        processor.ProcessMessageAsync += MessageHandler;
        processor.ProcessErrorAsync += ErrorHandler;

        await processor.StartProcessingAsync();

        Console.ReadKey();
    }
    finally
    {
        await processor.DisposeAsync();
        await client.DisposeAsync();
    }
}

static async Task MessageHandler(ProcessMessageEventArgs args)
{
    string body = args.Message.Body.ToString();
    Console.WriteLine(body);

    // we can evaluate application logic and use that to determine how to settle the message.
    await args.CompleteMessageAsync(args.Message);
}

static Task ErrorHandler(ProcessErrorEventArgs args)
{
    // the error source tells me at what point in the processing an error occurred
    Console.WriteLine(args.ErrorSource);

    // the fully qualified namespace is available
    Console.WriteLine(args.FullyQualifiedNamespace);

    // as well as the entity path
    Console.WriteLine(args.EntityPath);
    Console.WriteLine(args.Exception.ToString());
    return Task.CompletedTask;
}

ServiceBusProcessorOptions

var options = new ServiceBusProcessorOptions
{
    ReceiveMode = ServiceBusReceiveMode.PeekLock,
    AutoCompleteMessages = true,
    MaxAutoLockRenewalDuration = TimeSpan.FromMinutes(5),  //  renew the lock automatically till duration
    MaxConcurrentCalls = 1,  // number of messages processed concurrently
    PrefetchCount = 0,  // quietly acquire messages, up to the PrefetchCount limit
    SubQueue = SubQueue.None
};
var processor = client.CreateProcessor(TopicName, SubscriptionName, options);

Receive mode	Description
PeekLock	The client sends a request to receive a message from Service Bus. Then it sends a request to complete / abandon / defer / dead-letter the message.
ReceiveAndDelete	The send of a request to receive a message and the send of the request to complete the message are combined in a single request. This reduces the overall number of operations, and can improve the overall message throughput. This performance gain comes at the risk of losing messages.

Auto-complete messages	Description
true	Automatically complete messages after the message handler has completed processing without any exception raised. No need to call `await args.CompleteMessageAsync(message);`
false	Don't complete the message processing automatically. A request is required to manually complete / abandon / defer / dead-letter the message.

SubQueue	Description
None	No subqueue
DeadLetter	Add a secondary subqueue to hold messages that can't be delivered to any receiver.
TransferDeadLetter	Add a secondary subqueue to hold messages that can't be delivered to any receiver when the following conditions apply: a message passes through more than four queues or topics that are chained together the destination queue or topic is disabled or deleted the destination queue or topic exceeds the maximum entity size