Question

How could be defined a code that store ‘this’ during class finalization? How the garbage collector should behave (if defined somewhere)?

In my mind the GC should finalize multiple times the class instance, and the following test application shall print “66”, but the finalizer is executed only once, causing the application to print “6”.

Few lines of code:

using System;

namespace Test
{
    class Finalized
    {
        ~Finalized()
        {
            Program.mFinalized = this;
        }

        public int X = 5;
    }

    class Program
    {
        public static Finalized mFinalized = null;

        static void Main(string[] args)
        {
            Finalized asd = new Finalized();
            asd.X = 6;
            asd = null;
            GC.Collect();

            if (mFinalized != null)
                Console.Write("{0}", mFinalized.X);

            mFinalized = null;
            GC.Collect();

            if (mFinalized != null)
                Console.Write("{0}", mFinalized.X);
        }
    }
}

What I’m trying to do is to understand how finalizers manage instance memory. In my application could be desiderable to re-use instance reference again for further processing.

It’s clear that the finalizer doesn’t “free” memory (at least in my test application). May the memory chunk be reused for other purposes? Or even freed? And if it isn’t, that would be a memory leak or what?

Now, I’m confused more than before.

Answer 1

This is due to Resurrection. By storing the object in another variable during finalization (assigning this to a variable), you resurrect the obejct instance as far as the GC is concerned. You are allowed to resurrect your object in .NET, and you can actually cause the GC to finalize the object more than once, but you have to explicitly request it via GC.ReRegisterForFinalize .

For details, see Automatic Memory Management in the Microsoft .NET Framework.