DelayQueue.Core 3.0.2

Delayed Message Processing: Execute tasks at specified future timestamps

Redis Backed: Utilizes Redis for reliable message storage and coordination

Automatic Retry: Failed consumer executions trigger automatic retry mechanisms

Scalable Consumers: Support for multiple consumer instances per topic

Topic-based Organization: Messages organized by topics for structured processing

Installation Add the delay queue service to your application:

services.AddDelayQueue(configuration.GetSection("DelayQueueRedis"))
    .AddProducer(configuration.GetSection("DelayQueueProducer"))
    .AddConsumer(configuration.GetSection("DelayQueueConsumer"))
    .AddCoordinator(configuration.GetSection("DelayQueueCoordinator"));

This automatically injects:

CoordinatorFactory - For managing topic coordination

ConsumerFactory - For creating message consumers

ProducerFactory - For publishing delayed messages

{
  "DelayQueueRedis": {
    // Redis settings
  },
  "DelayQueueProducer": {
    // Producer settings
  },
  "DelayQueueConsumer": {
    // Consumer settings
  },
  "DelayQueueCoordinator": {
    // Coordinator settings
  }
}

Dependency Injection

        var ProducerFactory = provider.GetRequiredService<ProducerFactory>();
        var consumerFactory = provider.GetRequiredService<ConsumerFactory>();
        var coordinatorFactory = provider.GetRequiredService<CoordinatorFactory>();

Usage Producer Publish delayed messages to a topic:

await ProducerFactory.CreateProducer("TaskTopic").PublishAsync(task.id, task.task_executiontime);

Consumer Consume messages from a topic. Return true on successful processing, false or throw exceptions to trigger retries:

for (int i = 0; i < 4; i++)
{
    await ConsumerFactory.CreateConsumer("TaskTopic").StartAsync(async (taskid, timestamp) =>
    {
        Console.WriteLine(taskid);
        // Process the message
        return true; // Return false to trigger retry
    });
}

Coordinator Each topic requires a coordinator instance:

await CoordinatorFactory.CreateCoordinator("TaskTopic").StartAsync().ConfigureAwait(false);

Error Handling Consumers returning false will trigger message retry

Exceptions thrown in consumer handlers will trigger retry

Ensure idempotent processing in consumer logic

Notes Each TaskTopic must have exactly one coordinator instance running

Multiple consumers can process messages from the same topic concurrently

Message timestamps should be in Unix timestamp format

Ensure proper error handling and logging in consumer implementations