Intent.Eventing.MassTransit.Scheduling

This module extends the Intent.Eventing.MassTransit module by adding the ability to schedule messages for delivery at a specific time or after a delay.

For more info on MassTransit scheduling, check out their documentation.

Note

Some Message Brokers (like RabbitMQ) require plugins to be installed or configured for scheduled messages to work. Please see the MassTransit documentation for more info on your specific broker.

What's in this module?

This module enhances the Intent.Eventing.MassTransit module in the following ways:

• Extends the IMessageBus interface with scheduling methods
• Configures scheduling infrastructure for your selected message broker
• Implements scheduling methods in the MassTransitEventBus class

Scheduling Methods

This module adds two scheduling methods to the IMessageBus interface:

public interface IMessageBus
{
    // ... existing methods ...
    
    /// <summary>
    /// Schedules a message to be published at a specific UTC time.
    /// </summary>
    /// <typeparam name="TMessage">The message type.</typeparam>
    /// <param name="message">The message instance to schedule.</param>
    /// <param name="scheduled">The UTC date/time when the message should be dispatched.</param>
    void SchedulePublish<TMessage>(TMessage message, DateTime scheduled) where TMessage : class;
    
    /// <summary>
    /// Schedules a message to be published after a delay relative to the current UTC time.
    /// </summary>
    /// <typeparam name="TMessage">The message type.</typeparam>
    /// <param name="message">The message instance to schedule.</param>
    /// <param name="delay">The time span to add to the current UTC time for scheduling.</param>
    void SchedulePublish<TMessage>(TMessage message, TimeSpan delay) where TMessage : class;
}

Usage Example

public class OrderService
{
    private readonly IMessageBus _messageBus;

    public OrderService(IMessageBus messageBus)
    {
        _messageBus = messageBus;
    }

    public async Task ScheduleOrderReminder(Order order)
    {
        // Schedule an order reminder to be sent 7 days from now
        _messageBus.SchedulePublish(
            new OrderReminderEvent { OrderId = order.Id },
            TimeSpan.FromDays(7));
        
        await _messageBus.FlushAllAsync();
    }

    public async Task ScheduleExpiration(Order order)
    {
        // Schedule an expiration check at a specific time
        var expirationTime = DateTime.UtcNow.AddHours(24);
        _messageBus.SchedulePublish(
            new OrderExpirationEvent { OrderId = order.Id },
            expirationTime);
        
        await _messageBus.FlushAllAsync();
    }
}

Multi-Provider Scheduling

When this module is installed alongside other message bus providers, the scheduling methods operate across all installed providers that have been designated to handle the message type.

For example, if you have both MassTransit and Kafka configured:

• Messages designated for MassTransit will be scheduled using MassTransit's scheduling capabilities
• Messages designated for Kafka will be handled by Kafka's implementation
• Messages can be scheduled for multiple providers simultaneously if they're marked for both

The scheduling methods ensure consistent behavior across different message bus implementations, allowing you to use the same code regardless of which provider(s) are handling your messages.

For more details on the multi-provider architecture and message designation, see the Intent.Eventing.Contracts documentation.