在C＃中如何知道是否弱引用对象将被垃圾回收？

Question

Suppose I have such code:

class Test
{
    WeakReference m_ref;

    public Test()
    {
        Test1();
        Test2();
    }

    void Test1()
    {
        m_ref = new WeakReference(new object());
    }

    void Test2()
    {
        // If I do the GC then the m_ref.Target is null
        // GC.Collect();
        Debug.Log(m_ref.Target);
    }
}

void TestFunc()
{
    new Test();
}

In this example I created a new object instance and set it to a WeakReference instance in Test1 . If I understand correctly after exit the Test1 there would be nothing referenced to the object instance so this instance would be GC soon.

However, in the Test2 if GC is not performed I can still access the object instance via m_ref.Target .

Is there any way I could know that the m_ref.Target is invalid without manually perform the GC ?

Answer 1

Nope, you can't. By design, WeakReference is tightly coupled to the garbage collector. Even the documentation mentions it:

Gets an indication whether the object referenced by the current WeakReference object has been garbage collected.

As far as I know, there's no way in C# to know whether there's still alive references to a given object, except maybe manually browsing the whole reference tree (and pretty much reimplementing the GC yourself).

Answer 2

Is there any way I could know that the m_ref.Target is invalid without manually perform the GC?

It is not invalid until the GC collects the object. The point of garbage collection is that you don't know and you don't have to take care of when the object is going to be discarded.

In your example, yes, you are right that after m_ref = new WeakReference(new object()); is executed, the instance will be collected 'soon'. However, 'soon' is not defined specifically whatsoever, so you cannot presume this will happen before Test2 is invoked and Debug.Log(m_ref.Target); executed.

Answer 3

If I understand correctly after exit the Test1 there would be nothing referenced to the object instance ...

You are wrong. Technically you don't have any reference of created object, it may be gc'ed on the next line.

Consider this simple example:

class Program
{
    static WeakReference _ref;

    static void Main(string[] args)
    {
        Test();
        GC.Collect();
        Console.WriteLine(_ref.IsAlive); // false
    }

    static void Test()
    {
        var obj = new object();
        _ref = new WeakReference(obj);
        GC.Collect();
        Console.WriteLine(_ref.IsAlive); // true
    }
}

In Test() we have strong reference to an object, it indeed persist until end of method.

You can do something like this to be sure

object obj = _ref.Target;
if (obj != null)
{
    ... safe to do something with obj
}

Answer 4

You can not tell if a WeakReference is valid. But you can tell if it is invalid. I know that is strange. If I have code that does an if statement and could ask "is it valid" then it could be invalid on the next line of code, so it is useless. The TryGetTarget call on WeakReference gets a reference to the object, or fails and returns false. Once it has a reference, the reference prevents the object from being garbage collected, so it will stay valid at least as long as you have the reference.

In some code one might be keeping a List<WeakReference<MyNiftyClass>>

One great way to keep track of that list and keep it clean of unreferenced (elsewhere) references is to have some for loop scan the list with TryGetTarget and if it fails remove the stale reference from the list. But a removal like that wrecks the iterator so you want to use RemoveAll with a predicate. I have a class called CognateBase and a static global list called AllCognateBases. The CognateBase has a Tick() function I call every time tick of the program. The Tick loop is a good place to reap stale references. So I have...

    public static void TickAll()
    {
        // This will loop through all CognateBase objects and call their Tick, or if deleted from memory, remove the CognateBase.
        AllCognateBases.RemoveAll(_TickIfAble);
    }

And then the _TickIfAble is

private static bool _TickIfAble(WeakReference<CognateBase> r)
    {
        CognateBase cb;
        if (r.TryGetTarget(out cb))
        {
            cb.Tick();
            return false;
        }
        else
        {
            return true;
        }
    }

Thus the CognateBase instances that are valid get ticked, and the ones that are not valid any more get removed. And because it is in RemoveAll there is no iterator to get messed up.

Anywhere else in the code where I have a reference to a CognateBase and set it to null, the CognateBase will eventually get deleted and removed from the list.

And this test works. All those GC calls are to force Garbage Collection to happen NOW not some time later when C# feels like it.

        public static void UnitTest()
    {
        Debug.Assert(AllCognateBases.Count == 0);
        CognateBase b1 = new CognateBase();
        Debug.Assert(AllCognateBases.Count == 1);
        CognateBase b2 = new CognateBase();
        Debug.Assert(AllCognateBases.Count == 2);
        GC.Collect();
        Debug.Assert(AllCognateBases.Count == 2);

        b1 = null;
        GC.Collect();
        GC.WaitForFullGCComplete();
        GC.WaitForPendingFinalizers();
        TickAll();
        GC.Collect();
        GC.WaitForFullGCComplete();
        GC.WaitForPendingFinalizers();
        Debug.Assert(AllCognateBases.Count == 1);

        b2 = null;
        GC.Collect();
        GC.WaitForFullGCComplete();
        GC.WaitForPendingFinalizers();
        TickAll();
        GC.Collect();
        GC.WaitForFullGCComplete();
        GC.WaitForPendingFinalizers();
        Debug.Assert(AllCognateBases.Count == 0);
    }

And the creator...

       public CognateBase()
    {
        AllCognateBases.Add(new WeakReference<CognateBase>(this));
    }

WARNING - WHen a reference is set to null like the above b1 = null; the objects may not get garbage collected for a looooooong time. All that time it is still valid and will get it's Tick called!