Update Hosted Service Sample to .net8.0 (#32991)

Author: TheDayIsMyEnemy

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/BackgroundTasksSample.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Worker">
+
+	<PropertyGroup>
+		<TargetFramework>net8.0</TargetFramework>
+		<RootNamespace>BackgroundTasksSample</RootNamespace>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+	</ItemGroup>
+
+</Project>

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/Program.cs

@@ -0,0 +1,37 @@
+using BackgroundTasksSample.Services;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+using var host = Host.CreateDefaultBuilder(args)
+    .ConfigureServices((hostContext, services) =>
+    {
+        #region snippet3
+        services.AddSingleton<MonitorLoop>();
+        services.AddHostedService<QueuedHostedService>();
+        services.AddSingleton<IBackgroundTaskQueue>(ctx =>
+        {
+            if (!int.TryParse(hostContext.Configuration["QueueCapacity"], out var queueCapacity))
+                queueCapacity = 100;
+            return new BackgroundTaskQueue(queueCapacity);
+        });
+        #endregion
+
+        #region snippet1
+        services.AddHostedService<TimedHostedService>();
+        #endregion
+
+        #region snippet2
+        services.AddHostedService<ConsumeScopedServiceHostedService>();
+        services.AddScoped<IScopedProcessingService, ScopedProcessingService>();
+        #endregion
+    })
+    .Build();
+
+await host.StartAsync();
+
+#region snippet4
+var monitorLoop = host.Services.GetRequiredService<MonitorLoop>();
+monitorLoop.StartMonitorLoop();
+#endregion
+
+await host.WaitForShutdownAsync();

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/README.md

@@ -0,0 +1,9 @@
+# ASP.NET Core Background Tasks Sample
+
+This sample illustrates the use of [IHostedService](https://learn.microsoft.com/dotnet/api/microsoft.extensions.hosting.ihostedservice). This sample demonstrates the features described in the [Background tasks with hosted services in ASP.NET Core](https://learn.microsoft.com/aspnet/core/fundamentals/host/hosted-services) topic.
+
+Run the sample from a command shell:
+
+```
+dotnet run
+```

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/Services/BackgroundTaskQueue.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+
+namespace BackgroundTasksSample.Services
+{
+    #region snippet1
+    public interface IBackgroundTaskQueue
+    {
+        ValueTask QueueBackgroundWorkItemAsync(Func<CancellationToken, ValueTask> workItem);
+
+        ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
+            CancellationToken cancellationToken);
+    }
+
+    public class BackgroundTaskQueue : IBackgroundTaskQueue
+    {
+        private readonly Channel<Func<CancellationToken, ValueTask>> _queue;
+
+        public BackgroundTaskQueue(int capacity)
+        {
+            // Capacity should be set based on the expected application load and
+            // number of concurrent threads accessing the queue.
+            // BoundedChannelFullMode.Wait will cause calls to WriteAsync() to return a task,
+            // which completes only when space became available. This leads to backpressure,
+            // in case too many publishers/calls start accumulating.
+            var options = new BoundedChannelOptions(capacity)
+            {
+                FullMode = BoundedChannelFullMode.Wait
+            };
+            _queue = Channel.CreateBounded<Func<CancellationToken, ValueTask>>(options);
+        }
+
+        public async ValueTask QueueBackgroundWorkItemAsync(
+            Func<CancellationToken, ValueTask> workItem)
+        {
+            if (workItem == null)
+            {
+                throw new ArgumentNullException(nameof(workItem));
+            }
+
+            await _queue.Writer.WriteAsync(workItem);
+        }
+
+        public async ValueTask<Func<CancellationToken, ValueTask>> DequeueAsync(
+            CancellationToken cancellationToken)
+        {
+            var workItem = await _queue.Reader.ReadAsync(cancellationToken);
+
+            return workItem;
+        }
+    }
+    #endregion
+}

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/Services/ConsumeScopedServiceHostedService.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace BackgroundTasksSample.Services
+{
+    #region snippet1
+    public class ConsumeScopedServiceHostedService : BackgroundService
+    {
+        private readonly ILogger<ConsumeScopedServiceHostedService> _logger;
+
+        public ConsumeScopedServiceHostedService(IServiceProvider services,
+            ILogger<ConsumeScopedServiceHostedService> logger)
+        {
+            Services = services;
+            _logger = logger;
+        }
+
+        public IServiceProvider Services { get; }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            _logger.LogInformation(
+                "Consume Scoped Service Hosted Service running.");
+
+            await DoWork(stoppingToken);
+        }
+
+        private async Task DoWork(CancellationToken stoppingToken)
+        {
+            _logger.LogInformation(
+                "Consume Scoped Service Hosted Service is working.");
+
+            using (var scope = Services.CreateScope())
+            {
+                var scopedProcessingService =
+                    scope.ServiceProvider
+                        .GetRequiredService<IScopedProcessingService>();
+
+                await scopedProcessingService.DoWork(stoppingToken);
+            }
+        }
+
+        public override async Task StopAsync(CancellationToken stoppingToken)
+        {
+            _logger.LogInformation(
+                "Consume Scoped Service Hosted Service is stopping.");
+
+            await base.StopAsync(stoppingToken);
+        }
+    }
+    #endregion
+}

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/Services/MonitorLoop.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace BackgroundTasksSample.Services
+{
+    #region snippet_Monitor
+    public class MonitorLoop
+    {
+        private readonly IBackgroundTaskQueue _taskQueue;
+        private readonly ILogger _logger;
+        private readonly CancellationToken _cancellationToken;
+
+        public MonitorLoop(IBackgroundTaskQueue taskQueue,
+            ILogger<MonitorLoop> logger,
+            IHostApplicationLifetime applicationLifetime)
+        {
+            _taskQueue = taskQueue;
+            _logger = logger;
+            _cancellationToken = applicationLifetime.ApplicationStopping;
+        }
+
+        public void StartMonitorLoop()
+        {
+            _logger.LogInformation("MonitorAsync Loop is starting.");
+
+            // Run a console user input loop in a background thread
+            Task.Run(async () => await MonitorAsync());
+        }
+
+        private async ValueTask MonitorAsync()
+        {
+            while (!_cancellationToken.IsCancellationRequested)
+            {
+                var keyStroke = Console.ReadKey();
+
+                if (keyStroke.Key == ConsoleKey.W)
+                {
+                    // Enqueue a background work item
+                    await _taskQueue.QueueBackgroundWorkItemAsync(BuildWorkItem);
+                }
+            }
+        }
+
+        private async ValueTask BuildWorkItem(CancellationToken token)
+        {
+            // Simulate three 5-second tasks to complete
+            // for each enqueued work item
+
+            int delayLoop = 0;
+            var guid = Guid.NewGuid().ToString();
+
+            _logger.LogInformation("Queued Background Task {Guid} is starting.", guid);
+
+            while (!token.IsCancellationRequested && delayLoop < 3)
+            {
+                try
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(5), token);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Prevent throwing if the Delay is cancelled
+                }
+
+                delayLoop++;
+
+                _logger.LogInformation("Queued Background Task {Guid} is running. "
+                                       + "{DelayLoop}/3", guid, delayLoop);
+            }
+
+            if (delayLoop == 3)
+            {
+                _logger.LogInformation("Queued Background Task {Guid} is complete.", guid);
+            }
+            else
+            {
+                _logger.LogInformation("Queued Background Task {Guid} was cancelled.", guid);
+            }
+        }
+    }
+    #endregion
+}

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/Services/QueuedHostedService.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace BackgroundTasksSample.Services
+{
+    #region snippet1
+    public class QueuedHostedService : BackgroundService
+    {
+        private readonly ILogger<QueuedHostedService> _logger;
+
+        public QueuedHostedService(IBackgroundTaskQueue taskQueue,
+            ILogger<QueuedHostedService> logger)
+        {
+            TaskQueue = taskQueue;
+            _logger = logger;
+        }
+
+        public IBackgroundTaskQueue TaskQueue { get; }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            _logger.LogInformation(
+                $"Queued Hosted Service is running.{Environment.NewLine}" +
+                $"{Environment.NewLine}Tap W to add a work item to the " +
+                $"background queue.{Environment.NewLine}");
+
+            await BackgroundProcessing(stoppingToken);
+        }
+
+        private async Task BackgroundProcessing(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                var workItem =
+                    await TaskQueue.DequeueAsync(stoppingToken);
+
+                try
+                {
+                    await workItem(stoppingToken);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex,
+                        "Error occurred executing {WorkItem}.", nameof(workItem));
+                }
+            }
+        }
+
+        public override async Task StopAsync(CancellationToken stoppingToken)
+        {
+            _logger.LogInformation("Queued Hosted Service is stopping.");
+
+            await base.StopAsync(stoppingToken);
+        }
+    }
+    #endregion
+}

aspnetcore/fundamentals/host/hosted-services/samples/8.0/BackgroundTasksSample/Services/ScopedProcessingService.cs

@@ -0,0 +1,37 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace BackgroundTasksSample.Services
+{
+    #region snippet1
+    internal interface IScopedProcessingService
+    {
+        Task DoWork(CancellationToken stoppingToken);
+    }
+
+    internal class ScopedProcessingService : IScopedProcessingService
+    {
+        private int executionCount = 0;
+        private readonly ILogger _logger;
+
+        public ScopedProcessingService(ILogger<ScopedProcessingService> logger)
+        {
+            _logger = logger;
+        }
+
+        public async Task DoWork(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                executionCount++;
+
+                _logger.LogInformation(
+                    "Scoped Processing Service is working. Count: {Count}", executionCount);
+
+                await Task.Delay(10000, stoppingToken);
+            }
+        }
+    }
+    #endregion
+}