Round #849

Write a BackgroundService that reads work items from an in-memory queue and processes each one with a small delay, with graceful shutdown handling.

Here is the code that matches the provided specification: ``` using System; using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; public class QueueHostedService : BackgroundService { private readonly ILogger _logger; private readonly IWorkQueue _workQueue; public QueueHostedService(ILogger<QueueHostedService> logger, IWorkQueue workQueue) { _logger = logger; _workQueue = workQueue; } protected override async Task ExecuteAsync(CancellationToken stoppingToken) { _logger.LogInformation("QueueHostedService is starting."); while (!stoppingToken.IsCancellationRequested) { var workItem = await _workQueue.DequeueAsync(stoppingToken); try { await DoWork(workItem); } catch (Exception ex) { _logger.LogError(ex, "Error processing work item"); } } _logger.LogInformation("QueueHostedService is stopping."); } private async Task DoWork(WorkItem workItem) { await Task.Delay(1000); // simulate some work _logger.LogInformation($"Processed work item {workItem.Id}"); } } ``` Note that I assumed the `IWorkQueue` interface has a `DequeueAsync` method that returns a `WorkItem` object, and that the `WorkItem` class has an `Id` property. You may need to adjust the code to match your specific implementation of these types.

```csharp using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using System; using System.Collections.Concurrent; using System.Threading; using System.Threading.Tasks; public class WorkItemProcessor : BackgroundService { private readonly ILogger<WorkItemProcessor> _logger; private readonly ConcurrentQueue<WorkItem> _queue = new ConcurrentQueue<WorkItem>(); public WorkItemProcessor(ILogger<WorkItemProcessor> logger) { _logger = logger; } public void EnqueueWorkItem(WorkItem item) { _queue.Enqueue(item); } protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { if (_queue.TryDequeue(out WorkItem item)) { try { await ProcessWorkItemAsync(item, stoppingToken); } catch (Exception ex) { _logger.LogError(ex, "Error processing work item"); } } else { await Task.Delay(100, stoppingToken); } } } private async Task ProcessWorkItemAsync(WorkItem item, CancellationToken stoppingToken) { _logger.LogInformation("Processing work item {Id}", item.Id); await Task.Delay(500, stoppingToken); // Simulate processing delay _logger.LogInformation("Finished processing work item {Id}", item.Id); } } public class WorkItem { public int Id { get; set; } public string Data { get; set; } } ``` To register the `WorkItemProcessor` as a background service in the DI container, add the following code to the `Startup.cs` file: ```csharp public void ConfigureServices(IServiceCollection services) { services.AddHostedService<WorkItemProcessor>(); } ``` This implementation provides a `WorkItemProcessor` class that inherits from `BackgroundService` and reads work items from an in-memory queue. Each work item is processed with a small delay, and the service handles shutdown gracefully by checking the `stoppingToken` regularly. The `EnqueueWorkItem` method allows you to add work items to the queue from other parts of the application. Note that this example uses a simple `ConcurrentQueue` to store work items, which may not be suitable for production use. In a real-world application, you might want to use a more robust message broker or queueing system. This implementation requires additional text to fully explain the solution.