Btukfyl

Let's consider this class:

public class A<T>

{

    private bool _flag;



    public Func<T> Function { get; set; } = () => {_flag = true; return _flag; }

}

Now, let's imagine that the Function property somehow accesses the _flag field with both read and write in its body. Then if I use the class A like this:

public Func<T> SomeFunction()

{

    var instance = new A();

    return instance.Function;

}

My question is what really happens, because I have originally assumed the instance would be disposed by GC when the SomeFunctions returns, which would mean the _flag would cease to exist and the Function would try to access nonexistent field when eventually called from somewhere, but that isn't what happens. The code seems to work. Is the field somehow preserved in a closure?

Thanks for clarification.

The GC will not remove the instance if there are still references to it. And a Func<> containing a reference to a field will hold a reference to the object (closure).

In the interest of simplicity, I will use a Dummy class (instead of your generic A):

class Dummy

{

    public int i = 0;



    ~Dummy()

    {

        Console.WriteLine("~Dummy --> " + i);

    }

}

Note the finalizer, which allows us to see the exact time at which it will be collected by the GC.

Now, consider this helper function: it creates a new Dummy d, then wraps it in a function closure and returns that closure.

static Func<int> MakeFunc()

{

    Dummy d = new Dummy();

    Func<int> f = () => {

        d.i++;

        Console.WriteLine("Func invoked, d.i is now " + d.i);

        return d.i;

    };

    return f;

}

We can call it like this:

public static void Main()

{

    Console.WriteLine("1");



    Func<int> f = MakeFunc();

    f();



    Console.WriteLine("2");

Output:

1

Func invoked, d.i is now 1

2

We can force a garbage collection cycle:

    GC.Collect();

    GC.WaitForPendingFinalizers();



    Console.WriteLine("3");

Output:

3

Note how we still haven't seen the finalizer running! The Dummy object is still alive, being held by the function closure.

In fact, we can continue to call the function:

    f();



    Console.WriteLine("4");

Output:

Func invoked, d.i is now 2

4

That Dummy instance will be finalized when we drop the reference and force another garbage collection cycle:

    f = null;



    GC.Collect();

    GC.WaitForPendingFinalizers();



    Console.WriteLine("5");

Output:

~Dummy --> 2

5

P.S.: Here I am using GC.Collect() for demonstration purposes. It's generally unnecessary (and inadvisable) to call it like this in production code.