Lambda表达式导致弱引用的目标不能被GC？

Question

namespace Test
{
    class Test
    {
        delegate void HandleMessage(string message);

        public void handleMessage(string message){}

        static void Main(string[] args)
        {
            HandleMessage listener1 = new Test().handleMessage;
            WeakReference w1 = new WeakReference(listener1);

            HandleMessage listener2 = (message) => { };
            WeakReference w2 = new WeakReference(listener2);

            Console.WriteLine("w1.Target:\t[" + w1.Target + "]");
            Console.WriteLine("w2.Target:\t[" + w2.Target + "]");

            listener1 = null;
            listener2 = null;
            GC.Collect();
            Console.WriteLine("after GC");

            Console.WriteLine("w1.Target:\t[" + w1.Target + "]");
            Console.WriteLine("w2.Target:\t[" + w2.Target + "]");

            Console.ReadLine();
        }
    }
}

为什么GC后w2.Target不为null？

    w1.Target:      [Test.Test+HandleMessage]
    w2.Target:      [Test.Test+HandleMessage]
    after GC
    w1.Target:      []
    w2.Target:      [Test.Test+HandleMessage]

编辑

感谢所有的答案，Brian Rasmussen 和 Jon Skeet，您的答案是正确的。 现在我彻底明白发生了什么，所以我写了另一个例子来让一切更清楚。

下面的示例表明：

如果 Test#create() 不引用任何实例属性或方法，则编译器将创建“private static HandleMessage CS$<>9__CachedAnonymousMethodDelegate1”，就像 Jon Skeet 所说的那样 - 这使得多次使用相同的 lambda 表达式会更有效。

如果 Test#create() 确实引用实例属性或方法，如下面的示例调用 this.ToString(); 那么编译器无法创建静态方法来替换实例方法的逻辑，因此在GC之后，可以收集HandleMessage实例。

namespace Test
{
    class Test
    {
        public delegate void HandleMessage(string message);

        public void handleMessage(string message)
        {
        }

        public HandleMessage create()
        {
            return (message) => { 
                //this.ToString(); 
            };
        }       

        static void Main(string[] args)
        {
            HandleMessage listener1 = new Test().handleMessage;
            WeakReference w1 = new WeakReference(listener1);

            HandleMessage listener2 = new Test().create();//(message) => { };
            WeakReference w2 = new WeakReference(listener2);

            Console.WriteLine("w1.Target:\t[" + w1.Target + "]");
            Console.WriteLine("w2.Target:\t[" + w2.Target + "]");

            listener1 = null;
            listener2 = null;
            GC.Collect();
            Console.WriteLine("after GC");

            Console.WriteLine("w1.Target:\t[" + w1.Target + "]");
            Console.WriteLine("w2.Target:\t[" + w2.Target + "]");

            Console.ReadLine();
        }
    }
}

Answer 1

它与 lambda 无关。 对于匿名委托，可以观察到相同的行为。 因此，如果您更改代码，

HandleMessage listener2 = delegate(string message) => { };

您会得到相同的结果。

在第一种情况下，您在 Test 实例上有一个实例方法。 由于当 listener1 为空时，您没有对此实例的其他引用，因此它可能会被收集。

在第二种情况下，匿名方法必须放置在某种类型上（因为方法不能单独存在）。 在这种情况下，编译器将匿名方法作为静态方法放置在您的 Test 类上。 此外，引用存储在 Test 类型的静态成员中。 因此，Type 也具有对该方法的静态引用，这就是它在集合中幸存下来的原因。

查看 IL 以了解事物是如何连接的。

Answer 2

lambda 表达式缓存在类中的静态字段中 - 当我编译它时，它位于 CS$<>9__CachedAnonymousMethodDelegate1 中。 当您多次使用相同的 lambda 表达式时，这会提高效率，但这意味着它不会被垃圾收集。

查看生成的 IL 就明白我的意思了。

如果 lambda 表达式捕获任何变量，我不相信它会被缓存（因为它不可能！）。 因此，如果您将代码更改为使用：，

string x = "hello";
HandleMessage listener2 = message => Console.WriteLine(x);

那么您将看到 w2.Target 在垃圾回收后变为 null。

Answer 3

强制收集内存的常见模式是：

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

此外，GC 可以自由地不收集东西:)