What is the best way to dispose static objects to handle graceful shutdown

[SuyliuMS]

Hi, team. We have some fixed number of static disposable instances that are throughout the lifecycle of the app process. These instances will force flush data to a backend service when dispose. We want to find a best way to dispose these static objects to handle graceful shutdown. Here are some thoughts from us:

1. We don’t want to rely on DI because that would pollute all constructors in our existing code.
2. Finalizer is not a secure way to dispose these instances. Because these instances will flush data to network, the finalizer may get stuck by network issues.

Here are the questions:

1. Is there any hook that dotnet runtime will call when application shutdown? We found IHostApplicationLifetime may help to register dispose on shutdown event, but we don't know if this is the best practice.
2. If application crushed, it seems only finalizer can handle graceful shutdown, right?
3. If the operations in finalizer crushed, like network issues in our static instance flushing, will runtime do something for graceful shutdown?
4. In general, what is the common practice/best way to dispose these static instances?

[Clockwork-Muse]

Finalizer is not a secure way to dispose these instances. Because these instances will flush data to network, the finalizer may get stuck by network issues.

A finalizer isn't a secure way to dispose of instances, period. There's no guarantee that they ever get called. In particular:

If application crushed, it seems only finalizer can handle graceful shutdown, right?

This isn't going to happen. .NET Core already doesn't run finalizers when the application is gracefully shutting down (because the held resource will be released anyways), and an application crash may stop the process "immediately", not letting any further code run. Creating fault-tolerant applications is hard. You've mentioned network issues, but your application has no guarantee the network ever comes back, and any new actions you take at that point, like writing to a local file, can fail as well.

We have some fixed number of static disposable instances that are throughout the lifecycle of the app process.

.... preferably, don't do this. It makes it harder to test your code, and creates hidden internal dependencies.

That said:

In general, what is the common practice/best way to dispose these static instances?

Manually call .Dispose() during application shutdown, and ensure that the instance can't/won't be used again. Anticipate that it can fail, in all sorts of ways. Note that, depending on your application usage, you may need to also have a Flush() method that gets called on a timer.

[MSDN-WhiteKnight]

AppDomain.ProcessExit is a recommended API to do cleanup on shutdown. This thread has example: dotnet/docs#17463 (comment)