Add synchronous long running scenario.

[Atomosk]

Description

What will happen if ExecuteAsync is a synchronous and is a really long running, like several hours?

StartAsync will hang for a long time and the rest of that application will wait for that quote background service to finish what it does.

How can we avoid this? Should we use Task.Run or Task.Factory.StartNew with a LongRunning parameter or add await Task.Delay(1) to the first line of ExecuteAsync or Thread + TaskCompletitionSource or something else? Searching for an answer to this question is harder than it might look.

So I think this article is a perfect place to show a solution to that problem, which is very common I believe.

Page URL

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/host/hosted-services?view=aspnetcore-9.0&tabs=visual-studio

Content source URL

https://github.com/dotnet/AspNetCore.Docs/blob/main/aspnetcore/fundamentals/host/hosted-services.md

Document ID

b2dece1f-15b8-03af-6d52-7cc070432b4b

Article author

@tdykstra

---

Associated WorkItem - 345246

[tdykstra]

Here are some suggestions provided by GitHub Copilot (I haven't tested them):

To avoid blocking the StartAsync method when ExecuteAsync is long-running, you can use Task.Run to run the long-running task on a separate thread. This way, StartAsync can complete quickly, and the rest of the application can continue to run without waiting for the background service to finish.

Here is an example of how you can modify your hosted service to use Task.Run:

public class LongRunningService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await Task.Run(() => LongRunningTask(stoppingToken), stoppingToken);
    }

    private void LongRunningTask(CancellationToken stoppingToken)
    {
        // Simulate a long-running task
        while (!stoppingToken.IsCancellationRequested)
        {
            // Perform work here
            Thread.Sleep(1000); // Simulate work
        }
    }
}

In this example, Task.Run is used to run the LongRunningTask method on a separate thread, allowing ExecuteAsync to complete quickly. This ensures that StartAsync does not hang and the rest of the application can continue to run.

Using Task.Delay in the ExecuteAsync method can also help to avoid blocking the StartAsync method. By adding a small delay at the beginning of ExecuteAsync, you allow StartAsync to complete quickly. Here is an example of how you can modify your hosted service to use Task.Delay:

public class LongRunningService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Add a small delay to allow StartAsync to complete
        await Task.Delay(1, stoppingToken);

        // Simulate a long-running task
        while (!stoppingToken.IsCancellationRequested)
        {
            // Perform work here
            await Task.Delay(1000, stoppingToken); // Simulate work
        }
    }
}

In this example, Task.Delay(1) is used to introduce a small delay at the beginning of ExecuteAsync. This allows StartAsync to complete quickly, and the rest of the application can continue to run without waiting for the background service to finish.