How to Gracefully Stop Your .NET Core Hosted Services After Task Completion

Learn how to rewrite your `IHostedService` to stop an application once all tasks are completed, ensuring efficiency in your .NET Core projects.
---
This video is based on the question https://stackoverflow.com/q/66116983/ asked by the user 'serge' ( https://stackoverflow.com/u/961631/ ) and on the answer https://stackoverflow.com/a/66117596/ provided by the user 'Maxim Zabolotskikh' ( https://stackoverflow.com/u/1105564/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: rewrite an IHostedService to stop after all tasks finished

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/licensing
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/by-sa/4.0/ ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/by-sa/4.0/ ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Stopping .NET Core Hosted Services After Task Completion

If you've ever worked with .NET Core applications, you're likely aware of the IHostedService interface. It's commonly used to create long-running background services. However, a typical concern many developers face is how to gracefully stop these services after their tasks are completed. In this guide, we will discuss a real-world scenario where an application needs to shut down after executing scheduled tasks on databases and how to implement this using proper techniques.

The Challenge

Let's start with a basic scenario. Imagine you have built a console application (.NET Core) that connects to two databases, executing updates through two designated services:

ContosoService for ContosoDatabase

AlonsoService for AlonsoDatabase

Despite intending for the application to stop its execution after completing the updates, the default behavior of IHostedService doesn't allow for this. Instead, the application remains running indefinitely, which can be frustrating. The initial implementation might look something like this:

[[See Video to Reveal this Text or Code Snippet]]

Your Main method might look like this, where you invoke the host:

[[See Video to Reveal this Text or Code Snippet]]

However, simply placing Environment.Exit(0); at the end of your Main method does not provide the desired results because the application will continue running as long as the hosted service is active.

Understanding Hosted Services

Background Services Versus Application Termination

It's important to recognize that IHostedService is designed for background processing. The services are not intended to dictate the lifecycle of your main application. Instead, they can respond to application start and stop events. Hence, they will typically remain active as long as the application is running.

So what's the solution?

There are two robust strategies to effectively manage application termination after all tasks are complete.

Solutions to Gracefully Stop Hosted Services

Strategy 1: Use IHostApplicationLifetime

One effective way to programmatically manage the application's lifecycle is by using IHostApplicationLifetime. Here’s how to implement this in your service:

Inject IHostApplicationLifetime into your IHostedService constructor.

[[See Video to Reveal this Text or Code Snippet]]

Call StopApplication() when your tasks are complete.

[[See Video to Reveal this Text or Code Snippet]]

This strategy allows you to effectively shut down the application once your background task processing is complete, ensuring a graceful exit without needing to call Environment.Exit directly.

Strategy 2: Awaiting Tasks

An alternative method is to manage tasks directly within your Main method. Instead of using IHostedService, you can create and await your tasks as follows:

Run Tasks Directly in Main:

[[See Video to Reveal this Text or Code Snippet]]

This method utilizes regular tasks which can be awaited, giving you direct control over the application lifecycle based on task completion.

Conclusion

In summary, managing hosted services in .NET Core to achieve a graceful shutdown can be done effectively using IHostApplicationLifetime or direct task management in your Main method. Both strategies will ensure that your application stops after all tasks are completed, improving performance and resource management.

When developing services or applications in .NET Core, considering the lifecycle and execution of hosted services can greatly enhance the user experience and overall system efficiency. Stay tuned for more practical tips on .NET Core development!

Видео How to Gracefully Stop Your .NET Core Hosted Services After Task Completion канала vlogize