> For the complete documentation index, see [llms.txt](https://brightercommand.gitbook.io/paramore-brighter-documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://brightercommand.gitbook.io/paramore-brighter-documentation/scheduler/brighterschedulersupport/inmemoryscheduler.md). # InMemory Scheduler The InMemory Scheduler is a lightweight, timer-based scheduling implementation provided by Brighter for testing, development, and demonstration purposes. > **Reference** · Applies to **Brighter V10** The **InMemory Scheduler** is a lightweight, timer-based scheduling implementation provided by Brighter for **testing, development, and demonstration purposes**. It requires no external dependencies and stores scheduled jobs in memory using timers. ## Important Warning **The InMemory Scheduler is NOT durable and is NOT recommended for production use.** * **No Persistence**: All scheduled jobs are lost if the application crashes or restarts * **No Distribution**: Cannot be shared across multiple application instances * **No Recovery**: Failed jobs are not automatically retried after restart * **Memory Bound**: All scheduled jobs are held in memory **Use this scheduler for:** * Unit and integration tests * Local development * Demos and proof-of-concepts * Production scenarios where losing scheduled work is acceptable ## What is the InMemory Scheduler? The InMemory Scheduler uses .NET's `ITimerProvider` internally to schedule delayed execution of messages. When you schedule a message: 1. Brighter creates an in-memory timer for the specified delay 2. The timer fires at the scheduled time 3. Brighter dispatches your message to the appropriate handler 4. The timer is removed from memory This simple approach makes it perfect for testing but unsuitable for production systems that require durability. ## InMemory Scheduler Architecture ``` Your Code ↓ CommandProcessor.SendAsync(delay, command) ↓ InMemoryScheduler ↓ ITimerProvider.CreateTimer(delay) ↓ [Timer stored in memory] ↓ [Timer fires after delay] ↓ CommandProcessor dispatches command ↓ Your Handler executes ``` ## When to Use InMemory Scheduler ### Recommended Use Cases **Unit Testing:** ```csharp [Fact] public async Task Should_Schedule_Command_For_Later_Execution() { // Arrange var services = new ServiceCollection(); services.AddBrighter(options => { ... }) .UseScheduler(new InMemorySchedulerFactory()) // Perfect for tests .AutoFromAssemblies(); var provider = services.BuildServiceProvider(); var commandProcessor = provider.GetRequiredService(); // Act var schedulerId = await commandProcessor.SendAsync( TimeSpan.FromMilliseconds(100), new TestCommand(), ); // Assert Assert.NotNull(schedulerId); await Task.Delay(150); // Wait for scheduled execution // Verify command was handled... } ``` ### Limited Production Scenarios The InMemory Scheduler might be acceptable in production **only if**: * Loss of scheduled work is acceptable (non-critical notifications, analytics, etc.) * Your application rarely restarts * Scheduled work has short delays (minutes, not hours/days) * You have alternative mechanisms to recover lost work **Example - Acceptable Production Use:** ```csharp // Low-priority analytics events that can be lost public class AnalyticsService { private readonly IAmACommandProcessor _commandProcessor; public async Task TrackUserAction(string userId, string action) { // Track immediately await _repository.SaveActionAsync(userId, action); // Schedule low-priority aggregation (acceptable to lose) await _commandProcessor.SendAsync( TimeSpan.FromMinutes(5), new AggregateAnalyticsCommand { UserId = userId } ); } } ``` ## InMemory Scheduler Configuration ### InMemory Scheduler Factory Options `InMemorySchedulerFactory` takes no constructor arguments, so `new InMemorySchedulerFactory()` is a complete configuration; these four properties are what you can change about it. | Option | Type | Default | Description | | ------------------------------- | ------------------------ | ------------------------------ | ------------------------------------------------------------------------------------------------------ | | `TimeProvider` | `TimeProvider` | `TimeProvider.System` | The clock the scheduler measures delays against, and the seam a `FakeTimeProvider` replaces in a test. | | `GetOrCreateMessageSchedulerId` | `Func` | a fresh identifier per message | Names the timer Brighter creates for a message. | | `GetOrCreateRequestSchedulerId` | `Func` | a fresh identifier per request | Names the timer Brighter creates for a request. | | `OnConflict` | `OnSchedulerConflict` | `Throw` | What Brighter does when a timer with the same identifier already exists. | `OnSchedulerConflict` is `Throw` or `Overwrite`. ### Basic Configuration Configure the InMemory Scheduler with `InMemorySchedulerFactory`: ```csharp using Paramore.Brighter.Extensions.DependencyInjection; using Paramore.Brighter; var builder = WebApplication.CreateBuilder(args); builder.Services.AddBrighter(options => { options.HandlerLifetime = ServiceLifetime.Scoped; }) .UseScheduler(new InMemorySchedulerFactory()) // Add InMemory Scheduler .AutoFromAssemblies(); var app = builder.Build(); ``` ### Environment-Specific Configuration Use InMemory for development, production schedulers elsewhere: ```csharp using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using Paramore.Brighter; using Paramore.Brighter.Extensions.DependencyInjection; using Paramore.Brighter.MessageScheduler.Hangfire; var builder = WebApplication.CreateBuilder(args); var brighter = builder.Services.AddBrighter(options => { options.HandlerLifetime = ServiceLifetime.Scoped; }); // UseScheduler needs one type that is both a message and a request scheduler factory, // so choose the concrete factory here; a helper could only return one of the two interfaces if (builder.Environment.IsDevelopment() || builder.Environment.IsEnvironment("Testing")) { brighter.UseScheduler(new InMemorySchedulerFactory()); } else { // Production - use a durable scheduler; Hangfire's storage is configured with AddHangfire brighter.UseScheduler(new HangfireMessageSchedulerFactory()); } brighter.AutoFromAssemblies(); ``` ### Configuration with Custom Timer Provider The InMemory Scheduler uses `ITimerProvider` internally. You can provide a custom implementation for testing: ```csharp public class FakeTimerProvider : ITimerProvider { public ITimer CreateTimer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period) { // Custom timer implementation for testing return new FakeTimer(callback, state, dueTime, period); } } // Use in tests services.AddBrighter(options => { ... }) .UseScheduler(new InMemorySchedulerFactory(new FakeTimerProvider())) .AutoFromAssemblies(); ``` ## InMemory Scheduler NuGet Package To use the InMemory Scheduler, install the NuGet package: ```bash dotnet add package Paramore.Brighter.InMemoryScheduler ``` **Package**: `Paramore.Brighter.InMemoryScheduler` ## InMemory Scheduler Code Examples ### Basic Scheduling Schedule a command with a delay: ```csharp public class OrderService { private readonly IAmACommandProcessor _commandProcessor; public async Task CreateOrder(Order order) { await _repository.SaveAsync(order); // Schedule order confirmation email for 5 minutes later var schedulerId = await _commandProcessor.SendAsync( TimeSpan.FromMinutes(5), new SendOrderConfirmationCommand { OrderId = order.Id } ); _logger.LogInformation("Scheduled confirmation email: {SchedulerId}", schedulerId); } } ``` ### Scheduling with Absolute Time Schedule for a specific time: ```csharp public class ReportService { private readonly IAmACommandProcessor _commandProcessor; public async Task ScheduleDailyReport() { // Schedule for tomorrow at 9 AM var tomorrow9AM = DateTimeOffset.UtcNow.Date.AddDays(1).AddHours(9); var schedulerId = await _commandProcessor.SendAsync( tomorrow9AM, new GenerateDailyReportCommand { Date = DateTime.UtcNow.Date } ); _logger.LogInformation("Scheduled daily report: {SchedulerId}", schedulerId); } } ``` ### Cancelling a Scheduled Job Cancel a previously scheduled job: ```csharp using System; using System.Threading.Tasks; using Microsoft.Extensions.Logging; using Paramore.Brighter; public class OrderService { // ... _repository and _logger, injected as your application supplies them private readonly IAmACommandProcessor _commandProcessor; private readonly IAmAMessageSchedulerAsync _scheduler; public async Task CancelOrder(Guid orderId) { var order = await _repository.GetAsync(orderId); // Cancel the scheduled confirmation email if (!string.IsNullOrEmpty(order.ConfirmationSchedulerId)) { await _scheduler.CancelAsync(order.ConfirmationSchedulerId); _logger.LogInformation("Cancelled scheduled email for order {OrderId}", orderId); } order.Status = OrderStatus.Cancelled; await _repository.UpdateAsync(order); } } ``` ### Testing with InMemory Scheduler Example unit test using InMemory Scheduler: ```csharp using System; using System.Threading.Tasks; using Microsoft.Extensions.DependencyInjection; using Paramore.Brighter; using Paramore.Brighter.Extensions.DependencyInjection; using Xunit; public class SchedulingTests : IDisposable { private readonly ServiceProvider _serviceProvider; private readonly IAmACommandProcessor _commandProcessor; private readonly TestHandlerRegistry _handlerRegistry; public SchedulingTests() { var services = new ServiceCollection(); _handlerRegistry = new TestHandlerRegistry(); services.AddBrighter(options => { options.HandlerLifetime = ServiceLifetime.Scoped; }) .UseScheduler(new InMemorySchedulerFactory()) // InMemory for tests .Handlers(_handlerRegistry) .AutoFromAssemblies(); _serviceProvider = services.BuildServiceProvider(); _commandProcessor = _serviceProvider.GetRequiredService(); } [Fact] public async Task Should_Execute_Scheduled_Command_After_Delay() { // Arrange var command = new TestCommand { Id = Guid.NewGuid() }; var delay = TimeSpan.FromMilliseconds(100); // Act var schedulerId = await _commandProcessor.SendAsync(delay, command); // Assert - command not yet executed Assert.False(_handlerRegistry.WasHandled(command.Id)); // Wait for scheduled execution await Task.Delay(delay.Add(TimeSpan.FromMilliseconds(50))); // Assert - command executed Assert.True(_handlerRegistry.WasHandled(command.Id)); } [Fact] public async Task Should_Cancel_Scheduled_Command() { // Arrange var command = new TestCommand { Id = Guid.NewGuid() }; var delay = TimeSpan.FromSeconds(10); // Long delay var scheduler = _serviceProvider.GetRequiredService(); // Act var schedulerId = await _commandProcessor.SendAsync(delay, command); await scheduler.CancelAsync(schedulerId); // Cancel immediately // Wait to ensure it would have executed await Task.Delay(TimeSpan.FromSeconds(11)); // Assert - command was NOT executed Assert.False(_handlerRegistry.WasHandled(command.Id)); } public void Dispose() { _serviceProvider?.Dispose(); } } ``` ## InMemory Scheduler Best Practices ### 1. Use for Testing Only ```csharp // Good - Environment-specific if (environment.IsDevelopment() || environment.IsEnvironment("Testing")) { services.UseScheduler(new InMemorySchedulerFactory()); } ``` ```csharp // Bad - Always using InMemory in production services.UseScheduler(new InMemorySchedulerFactory()); ``` ### 2. Document Production Limitations If you use InMemory in production, document why: ```csharp // PRODUCTION NOTE: Using InMemory scheduler because loss of // scheduled analytics aggregations is acceptable. These are // non-critical and will be regenerated on next sync. services.UseScheduler(new InMemorySchedulerFactory()); ``` ### 3. Keep Delays Short If using in production, keep delays under a few minutes: ```csharp // Good - Short delay acceptable to lose await _commandProcessor.SendAsync(TimeSpan.FromMinutes(2), command); // Bad - Long delay likely to be lost await _commandProcessor.SendAsync(TimeSpan.FromHours(24), command); ``` ### 4. Test Scheduler Behavior Write tests that verify scheduled behavior: ```csharp [Fact] public async Task Should_Handle_Concurrent_Scheduled_Commands() { // Schedule multiple commands with different delays var ids = new List(); for (int i = 0; i < 10; i++) { ids.Add(await _commandProcessor.SendAsync( TimeSpan.FromMilliseconds(50 + i * 10), new TestCommand { Number = i } )); } // Wait for all to execute await Task.Delay(TimeSpan.FromMilliseconds(200)); // Verify all were handled Assert.Equal(10, _handlerRegistry.HandledCount); } ``` ### 5. Don't Rely on It for Critical Work ```csharp // Bad - Critical payment processing await _commandProcessor.SendAsync( TimeSpan.FromMinutes(5), new ProcessPaymentCommand { Amount = 1000.00m } ); // Good - Critical work should use durable scheduler await _commandProcessor.SendAsync( TimeSpan.FromMinutes(5), new ProcessPaymentCommand { Amount = 1000.00m } ); // With Quartz or Hangfire in production ``` ## InMemory Scheduler Troubleshooting ### Scheduled Jobs Not Executing **Symptom**: Jobs scheduled but never execute **Possible Causes**: 1. Application stopped before timer fires 2. Delay too short (already passed) 3. Exception in handler preventing execution **Solution**: ```csharp // Add logging to verify scheduling var schedulerId = await _commandProcessor.SendAsync(delay, command); _logger.LogInformation("Scheduled job {SchedulerId} for {Delay}", schedulerId, delay); // Verify handler is registered Assert.NotNull(_serviceProvider.GetService>()); ``` ### Scheduled Jobs Lost After Restart **Symptom**: Application restart loses all scheduled jobs **Cause**: This is expected behavior - InMemory scheduler has no persistence **Solution**: Use a production scheduler (Quartz, Hangfire) if you need durability ### Memory Usage Growing **Symptom**: Memory consumption increases over time **Cause**: Too many scheduled jobs held in memory **Solution**: * Reduce number of concurrent scheduled jobs * Use shorter delays * Consider a production scheduler with external storage ## Related Documentation * [Brighter Scheduler Support](/paramore-brighter-documentation/scheduler/brighterschedulersupport.md) - Overview of scheduling in Brighter * [Switching Schedulers](/paramore-brighter-documentation/scheduler/switchingschedulers.md) - Moving to or from this scheduler * [Quartz Scheduler](/paramore-brighter-documentation/scheduler/brighterschedulersupport/quartzscheduler.md) - Production scheduler with persistence * [Hangfire Scheduler](/paramore-brighter-documentation/scheduler/brighterschedulersupport/hangfirescheduler.md) - Production scheduler with dashboard * [AWS Scheduler](/paramore-brighter-documentation/scheduler/brighterschedulersupport/awsscheduler.md) - Cloud-native AWS scheduling * [Azure Scheduler](/paramore-brighter-documentation/scheduler/brighterschedulersupport/azurescheduler.md) - Cloud-native Azure scheduling ## InMemory Scheduler Summary The InMemory Scheduler is a lightweight, zero-dependency scheduling solution perfect for: * **Unit and integration tests** - No external dependencies * **Local development** - Fast and simple * **Demos and POCs** - Quick to set up **NOT recommended for production** due to: * **No persistence** - Jobs lost on restart * **No distribution** - Single-process only * **No recovery** - No durability guarantees Use production schedulers (Quartz.NET, Hangfire, AWS Scheduler, Azure Service Bus Scheduler) for any system requiring durability and reliability. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://brightercommand.gitbook.io/paramore-brighter-documentation/scheduler/brighterschedulersupport/inmemoryscheduler.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.