Reliable way to hook .NET Core [6.0+] for low level memory management

[tilkinsc]

So I am fiddling with a C++ library that has generated bindings for C# automatically.

public class SoloudObject
{
    public IntPtr objhandle;
}

public class Soloud : SoloudObject, IDisposable
{

	......

	[DllImport(DLL_DIR, CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr Soloud_create();
	public Soloud()
	{
		objhandle = Soloud_create();
	}

	[DllImport(DLL_DIR, CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr Soloud_destroy(IntPtr aObjHandle);
	~Soloud()
	{
		Soloud_destroy(objhandle);
	}
	public void Dispose()
	{
		if (objhandle != IntPtr.Zero) {
			Soloud_destroy(objhandle);
			objhandle = IntPtr.Zero;
			GC.SuppressFinalize(this);
		}
	}

To my despair, I need a reliable way to have the destructor or dispose method be called. From what I know, the calling of the destructor is not guaranteed. Lets say the application experiences an unhandled exception, a seg fault, or plain as day Environment.Exit(int): how would I go about ensuring that this is handled?

In order to use SoLoud, you have to create a SoLoud::Soloud object.
The object must be cleaned up or destroyed before your back-end is shut down;
the safest way to do this is to call soloud.deinit() manually before terminating.

The object may be global, member variable, or even a local variable,
it can be allocated from the heap or the stack, as long as the above demand is met.
If the back-end gets destroyed before the back-end clean-up call is made, the result
is undefined. As in, bad. Most likely, a crash. Blue screens in Windows are not out
of the question.

source

AppDomain.ProcessExit

This method will not suffice. This method only works when Environment.Exit() or maybe even Application.Exit()

source

SafeHandles Class

This method is really... odd. It's ambiguous. It may work. It may not. It's primarily for Unmanaged Windows Handles as an alternative to IntPtr. Given that people have used this class to some success as I've seen in stackoverflow.

For my use-case here, Soloud_create() that is imported returns an IntPtr and the idea I have at this moment would be to convert this into a SafeHandle.

source

CriticalFinalizerObject

In classes derived from the CriticalFinalizerObject class, the common language runtime (CLR) guarantees that all critical finalization code will be given the opportunity to execute, provided the finalizer follows the rules for a CER, even in situations where the CLR forcibly unloads an application domain or aborts a thread.

This hits the nail on the hammer with what I am looking for. Its something that guarantees a class gets finalized. However, I would rather be told this is what I am looking for than to believe it. I believe my situation is entirely theoretical at the moment due to the variability of the task at hand. The idea is I let my code get marked as critical, in turn this should always get executed.

source
see also

[jkotas]

For graceful shutdown, it is best to do this sort of cleanup explicitly in the app main method. AppDomain.ProcessExit works too, but it is less ideal since you can run into ordering problems with other ProcessExit handlers.

For non-graceful shutdown (e.g. if the application crashes with fatal error or is killed), there is no way to cleanup reliably.