Using Rebus Deferred Messages for Background Processing in .NET

Publishing a Deferred Message

This is the core feature:

public class ReminderService
{
    private readonly IBus _bus;

    public ReminderService(IBus bus)
    {
        _bus = bus;
    }

    public async Task ScheduleReminderAsync(Guid userId, string reminderType, TimeSpan remindAfter)
    {
        var command = new SendReminderCommand
        {
            UserId = userId,
            ReminderType = reminderType, // e.g., "KYC", "StatusUpdate"
            OriginalActionDate = DateTimeOffset.UtcNow
        };

        // Defer the message until the desired time
        await _bus.Defer(remindAfter, command);
    }
}

The Command and Handler

public record SendReminderCommand
{
    public Guid UserId { get; init; }
    public string ReminderType { get; init; }
    public DateTimeOffset OriginalActionDate { get; init; }
}

public class SendReminderCommandHandler : IHandleMessages<SendReminderCommand>
{
    private readonly INotificationService _notificationService;
    private readonly IBus _bus;

    public SendReminderCommandHandler(INotificationService notificationService, IBus bus)
    {
        _notificationService = notificationService;
        _bus = bus;
    }

    public async Task Handle(SendReminderCommand message)
    {
        try
        {
            await _notificationService.SendReminderAsync(
                message.UserId, 
                message.ReminderType);

            // Optionally publish a completion event
            await _bus.Publish(new ReminderSentEvent
            {
                UserId = message.UserId,
                ReminderType = message.ReminderType,
                SentAt = DateTimeOffset.UtcNow
            });
            
            // OR schedule another reminder for the next timeout
        }
        catch (Exception ex)
        {
            // Rebus will retry based on your configuration
            throw;
        }
    }
}

Example Usage in Controller

[HttpPost("signup")]
public async Task<IActionResult> Signup(...)
{
    // After successful signup
    await _reminderService.ScheduleReminderAsync(
        userId: newUser.Id,
        reminderType: "KYC",
        remindAfter: TimeSpan.FromDays(7));

    return Ok();
}

Key Considerations

• Using TimeSpan is often simpler for relative delays (e.g., “7 days from now”, “48 hours after last activity”). Use DateTimeOffset when you need an exact calendar time (e.g., “remind on Monday at 9 AM”).

• Make handlers idempotent.

• Monitor your timeout storage as the number of deferred messages grows.

• Combine with Rebus Sagas if you need multi-step reminder workflows (e.g., escalate after 2nd reminder).

Conclusion

Switching from polling jobs to Rebus deferred messages for user reminders has made my background processing much cleaner and more maintainable. It fits naturally into event-driven architecture and reduces operational noise significantly.

Have you used deferred messaging for reminders or notifications? What patterns work best in your applications?

I’d love to hear your thoughts in the comments.