PEAK.Lib.MessageBrokerTrigger 1.1.0

PEAK.Lib.MessageBrokerTrigger

This guide provides instructions for handling messages using PEAK.Lib.MessageBrokerTrigger in two scenarios: Console Application and .NET API.

Default Constructor

public ServiceBusMessageTrigger(
            string connectionString,
            string queueName,
            bool isSession,
            Func<ServiceBusReceivedMessage, Task> messageHandler,
            bool isTopic = false,
            string? subscriptionName = null,
            ILogger? logger = null,
            ILoggerFactory? loggerFactory = null,
            string? loggerCategoryName = null)

Session Enabled, ServiceBusSessionProcessorOptions (Optional) Constructor

public ServiceBusMessageTrigger(
            string connectionString,
            string queueName,
            bool isSession = true,
            Func<ServiceBusReceivedMessage, Task> messageHandler,
            ServiceBusSessionProcessorOptions sessionProcessorOptions,
            ILogger? logger = null,
            ILoggerFactory? loggerFactory = null,
            string? loggerCategoryName = null)

Session Disabled, ServiceBusProcessorOptions (Optional) Constructor

public ServiceBusMessageTrigger(
            string connectionString,
            string queueName,
            bool isSession = false,
            Func<ServiceBusReceivedMessage, Task> messageHandler,
            ServiceBusProcessorOptions processorOptions,
            ILogger? logger = null,
            ILoggerFactory? loggerFactory = null,
            string? loggerCategoryName = null)

Topic/Sub Session Enabled, ServiceBusSessionProcessorOptions (Optional) Constructor

public ServiceBusMessageTrigger(
            string connectionString,
            string topicName,
            string? subscriptionName,
            bool isSession = true,
            Func<ServiceBusReceivedMessage, Task> messageHandler,
            ServiceBusSessionProcessorOptions sessionProcessorOptions,
            ILogger? logger = null,
            ILoggerFactory? loggerFactory = null,
            string? loggerCategoryName = null)

Topic/Sub Session Disabled, ServiceBusProcessorOptions (Optional) Constructor

public ServiceBusMessageTrigger(
            string connectionString,
            string topicName,
            string? subscriptionName,
            bool isSession = false,
            Func<ServiceBusReceivedMessage, Task> messageHandler,
            bool isTopic = true,
            string? subscriptionName,
            ServiceBusProcessorOptions processorOptions,
            ILogger? logger = null,
            ILoggerFactory? loggerFactory = null,
            string? loggerCategoryName = null)

Scenario 1. Console Application

Follow these steps to implement a message handler in a console application:

Code Example

using PEAK.Lib.MessageBrokerTrigger;

    internal static async Task Main(string[] args)
    {
        var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());

        Func<ServiceBusReceivedMessage, Task> messageHandler = (message) =>
        {
            var messageBody = message.Body.ToString();
            Console.WriteLine(messageBody);
            return Task.CompletedTask;
        };
        ServiceBusMessageTrigger serviceBusQueueMessageTrigger = new ServiceBusMessageTrigger(
            connectionString: "ServiceBusConnectionString",
            queueName: "YourQueueName",
            isSession: true,
            messageHandler,
            loggerFactory: loggerFactory,
            loggerCategoryName: nameof(Main)
        );
        await serviceBusQueueMessageTrigger.StartAsync();

        ServiceBusMessageTrigger serviceBusTopicMessageTrigger = new ServiceBusMessageTrigger(
            connectionString: "ServiceBusConnectionString",
            topicName: "YourTopicName",
            subscriptionName: "YourSubscriptionName",
            isSession: true,
            messageHandler,
            loggerFactory: loggerFactory,
            loggerCategoryName: nameof(Main)
        );
        await serviceBusTopicMessageTrigger.CreateSubscriptionWithRuleAsync("InvoiceRule", "TransactionType = 'Invoice'", true);
        await serviceBusTopicMessageTrigger.CreateSubscriptionWithRuleAsync("ReceiptRule", "TransactionType = 'Receipt'", true);

        await serviceBusTopicMessageTrigger.StartAsync();
        await Task.Delay(Timeout.Infinite);
    }

Scenario 2. .NET API

For a .NET API, you need to create a MessageBrokerTrigger class and register it as a service.

Step 1: Create the MessageBrokerTrigger Class

Here's an example implementation:

    public class MessageBrokerTrigger : IMessageBroker
    {
        private readonly ILoggerFactory _loggerFactory;
        private ServiceBusMessageTrigger? _serviceBusQueueMessageTrigger;
        private ServiceBusMessageTrigger? _serviceBusTopicMessageTrigger;
        public MessageBrokerTrigger(ILoggerFactory loggerFactory)
        {
            _loggerFactory = loggerFactory;
        }

        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (_serviceBusQueueMessageTrigger != null)
            {
                await _serviceBusQueueMessageTrigger.StopAsync(cancellationToken);
            }
            if (_serviceBusTopicMessageTrigger != null)
            {
                await _serviceBusTopicMessageTrigger.StopAsync(cancellationToken);
            }
        }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            Func<ServiceBusReceivedMessage, Task> messageHandler = (message) =>
            {
                var messageBody = message.Body.ToString();
                Console.WriteLine(messageBody);
                return Task.CompletedTask;
            };

            _serviceBusQueueMessageTrigger = new ServiceBusMessageTrigger(
                connectionString: "ServiceBusConnectionString",
                queueName: "YourQueueName",
                isSession: true,
                messageHandler,
                loggerFactory: _loggerFactory,
                loggerCategoryName: nameof(MessageBrokerTrigger)
            );
            await _serviceBusQueueMessageTrigger.StartAsync();

            _serviceBusTopicMessageTrigger = new ServiceBusMessageTrigger(
                connectionString: "ServiceBusConnectionString",
                topicName: "YourTopicName",
                subscriptionName: "YourSubscriptionName",
                isSession: true,
                messageHandler,
                loggerFactory: _loggerFactory,
                loggerCategoryName: nameof(MessageBrokerTrigger)
            );
            await _serviceBusTopicMessageTrigger.CreateSubscriptionWithRuleAsync("Rule", "filterExpression = 'Filter'");
            await _serviceBusTopicMessageTrigger.StartAsync();
        }
    }

Step 2: Register the MessageBrokerTrigger as a Service

Add the following lines to your Program.cs or Startup.cs (depending on the version of .NET you're using):

builder.Services.AddSingleton<MessageBrokerTrigger>();
builder.Services.AddHostedService<MessageBrokerTrigger>();

Notes

1. Replace "ServiceBusConnectionString", "YourTopicOrQueueName" Or "YourSubscriptionName" (if Topic) with the name of your actual Service Bus queue.
2. The Console Application example is designed to run indefinitely, while the .NET API example leverages IHostedService for lifecycle management.
3. Use proper logging instead of Console.WriteLine in production environments.

This structure ensures separation of concerns, maintainability, and readiness for deployment in both console applications and APIs.