How does finalisation work in .NET, why are finalisers expensive, and how do you diagnose a blocked finaliser thread?

1. The queues inside the GC

Allocation of finalisable object
        |
        v
+--------------------+     GC finds it unreachable     +----------------------+
| finalisation queue | ------------------------------> |  f-reachable queue   |  (a root!)
| (registered objs)  |                                 |  (ready to finalise) |
+--------------------+                                 +----------------------+
        ^                                                         |
        | GC.ReRegisterForFinalize                                v
        |                                              finaliser thread runs Finalize()
        |                                                         |
   GC.SuppressFinalize removes the entry                          v
                                                     next GC of its generation frees memory

Because the f-reachable queue is a root, everything reachable from a finalisable object is kept alive until its finaliser has run, then until the next GC that covers its (now promoted) generation.

2. What the compiler generates

class Foo { ~Foo() { Cleanup(); } }

becomes, in IL:

.method family hidebysig virtual instance void Finalize() cil managed
{
  .try { call instance void Foo::Cleanup()  leave.s END }
  finally { ldarg.0  call instance void [System.Runtime]System.Object::Finalize()  endfinally }
  END: ret
}

The ~Foo() syntax is an override of Object.Finalize with a try/finally that calls the base finaliser. The runtime detects the override when the type loads and uses the finalisable allocation path for every instance.

3. The dispose pattern with a finaliser (only if you must own a raw handle)

public class LegacyResource : IDisposable
{
    private IntPtr _native;      // raw handle: prefer SafeHandle instead!
    private bool _disposed;

    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        if (disposing)
        {
            // release managed disposables here
        }
        if (_native != IntPtr.Zero) { NativeFree(_native); _native = IntPtr.Zero; }
        _disposed = true;
    }

    ~LegacyResource() => Dispose(disposing: false); // never touch other managed objects here
}

In the finaliser path (disposing == false), other managed objects may already have been finalised, so only unmanaged state is touched.

4. Ordering and critical finalisers

• Among normal finalisers: no order. A StreamWriter and its FileStream can be finalised in either order, which is why StreamWriter doesn't flush in a finaliser.
• CriticalFinalizerObject (e.g. SafeHandle): among objects finalised together, critical finalisers run after normal ones. That lets a normal finaliser still use a SafeHandle field.

5. Process exit

Use IHostApplicationLifetime.ApplicationStopping, IAsyncDisposable on hosted services, AppDomain.ProcessExit or AssemblyLoadContext.Unloading for shutdown work.

6. Classic finaliser-thread blockers

7. Observability

• GC.GetGCMemoryInfo().FinalizationPendingCount: objects ready for finalisation at the last GC.
• GC heap stats events in traces report finalisation-promoted counts and sizes per GC.
• SOS: finalizequeue, clrthreads, clrstack, syncblk (to see lock owners).

8. Version notes

9. Try it yourself

1. Run the code example: the undisposed object survives the first GC; the disposed one doesn't.
2. Add Thread.Sleep(Timeout.Infinite) inside one finaliser, allocate 1 million finalisable objects, and watch FinalizationPendingCount and memory grow.
3. Take a dump of that process and run finalizequeue and clrstack on the finaliser thread.
4. Throw from a constructor of a type with a finaliser and log in the finaliser: it still runs on a partially built object.
5. Throw an exception from a finaliser and observe the process crash.
6. Benchmark allocating 10 million objects with and without a finaliser using BenchmarkDotNet.

using System.Runtime.CompilerServices;
using Microsoft.Win32.SafeHandles;

WeakReference leaked = Create(dispose: false);
WeakReference disposed = Create(dispose: true);

GC.Collect();
Console.WriteLine($"After 1 GC  - undisposed alive: {leaked.IsAlive}, disposed alive: {disposed.IsAlive}");

GC.WaitForPendingFinalizers();
GC.Collect();
Console.WriteLine($"After 2 GCs - undisposed alive: {leaked.IsAlive}");

[MethodImpl(MethodImplOptions.NoInlining)]
static WeakReference Create(bool dispose)
{
    var resource = new NativeResource();
    if (dispose) resource.Dispose();
    return new WeakReference(resource, trackResurrection: true);
}

// Preferred: no finaliser in your class; SafeHandle owns the native handle
public sealed class SafeBufferHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    public SafeBufferHandle() : base(ownsHandle: true) =>
        SetHandle(System.Runtime.InteropServices.Marshal.AllocHGlobal(1024));

    protected override bool ReleaseHandle()
    {
        System.Runtime.InteropServices.Marshal.FreeHGlobal(handle);  // never block or throw here
        return true;
    }
}

// Demonstration type with a finaliser (only to show the cost)
public sealed class NativeResource : IDisposable
{
    private readonly SafeBufferHandle _handle = new();
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);   // skip finalisation work
    }
    ~NativeResource() { /* safety net only: _handle has its own critical finaliser */ }
}