Question

[卫生署！我是个白痴..我在代码中根据对象生成..]

我的代码在Release中按预期工作，但在Debug中失败。

我有一个包含WeakReference个实例的词典到其他对象。在Release中，一旦未引用并且收集发生，字典就会“失去”其值。但是，在Debug中，它似乎没有发生......

即使在调试中，我确实看到在Debug中收集了其他WeakReference，但字典中的那些不是......

下面的代码显示了这一点。即使我在它们之间添加多个收集和延迟（Task.Delay(100)），它仍然不会消失。

任何想法如何强制WR被取消？我不介意太多，但我有一个测试测试，它将在Debug中失败。

以下是代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            DoIt();
            Console.ReadLine();
        }

        private static async void DoIt()
        {
            string key = "k1";
            var dict = new WeakItemDictionary<string, string>();
            var s = dict.GetOrAdd(key, k => String.Concat("sdsdsd", "sdsdsdsdsd"));
            RunFullGCCollection();
            var found = dict.GetItemOrDefault(key);
            Console.WriteLine(found == null ? "Object got collected" : "Object is still alive");
        }

        private static void RunFullGCCollection()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }

    /// <summary>
    /// Creates a dictionary of weakly referenced object that will disapear when no longer in use.
    /// Be careful when adding functions to the class - you need to take a bunch of scenarios into account.
    /// See how GetOrAdd() works for more info.
    /// </summary>
    /// <typeparam name="K">Key of the dictionary</typeparam>
    /// <typeparam name="V">Value type for the dictionary</typeparam>
    public class WeakItemDictionary<K, V> where V : class
    {
        public const int CleanPassFrequency = 10;
        private Dictionary<K, WeakReference<V>> _dictionary = new Dictionary<K, WeakReference<V>>();
        private int _addCount = 0;

        public V GetOrAdd(K key, Func<K, V> factory)
        {
            WeakReference<V> weakRef;
            V value = null;
            if (!_dictionary.TryGetValue(key, out weakRef))
            {
                value = factory(key);
                weakRef = new WeakReference<V>(value);
                _dictionary[key] = weakRef;
                _addCount++;
            }

            // If the value is null, try to get it from the weak ref (to root it).
            if (value == null)
            {
                value = weakRef.GetTargetOrDefault();

                // If the value is still null, means the weak ref got cleaned. We need to recreate (again, rooted)
                if (value == null)
                {
                    value = factory(key);
                    weakRef.SetTarget(value);
                    _addCount++;
                }
            }

            CleanIfNeeded();

            return value;
        }

        public V GetItemOrDefault(K key)
        {
            WeakReference<V> weakRef;
            V value = null;
            if (_dictionary.TryGetValue(key, out weakRef))
            {
                value = weakRef.GetTargetOrDefault();
            }

            return value;
        }

        private void CleanIfNeeded()
        {
            Lazy<List<K>> keysToRemove = new Lazy<List<K>>(false);

            foreach (var item in _dictionary)
            {
                if (item.Value.IsDead())
                {
                    keysToRemove.Value.Add(item.Key);
                }
            }

            if (keysToRemove.IsValueCreated)
            {
                foreach (var item in keysToRemove.Value)
                {
                    _dictionary.Remove(item);
                }
            }
        }
    }

    public static class Extensions
    {
        public static bool IsDead<T>(this WeakReference<T> weak) where T : class
        {
            T t;
            bool result = !weak.TryGetTarget(out t);
            return result;
        }

        public static T GetTargetOrDefault<T>(this WeakReference<T> weak) where T : class
        {
            T t;
            bool result = !weak.TryGetTarget(out t);
            return t;
        }


    }
}

Answer 1

        var s = dict.GetOrAdd(key, k => String.Concat("sdsdsd", "sdsdsdsdsd"));

您的s变量具有对象的引用。请注意，即使DoIt（）方法尚未执行，并且s变量仍存储在方法的激活框架中，您强制收集集合。当您在没有附加调试器的情况下运行Release构建时，它可以使垃圾收集器高效。但不是在你调试的时候。否则，首先存在Release配置的核心原因之一。

this post中详细解释了这种行为差异的技术原因。

不是你应该担心的事情，你只需要理解它为什么表现不同。您可以在调用GC.Collect（）之前将s设置为null来更改结果。或者将dict.GetOrAdd（）调用移动到另一个方法中。

Answer 2

根据Graphics2D：

弱引用允许垃圾收集器收集对象，同时仍然允许应用程序访问该对象。

许可意味着：垃圾收集器可以收集对象，但它不需要。所以你永远不知道它何时被收集。即使您在发布模式下运行它，有时.NET也不会收集它。

因此，即使你现在可以通过@Hans Passant的答案让它适应这种特殊情况，你也永远无法确定它是否总能以同样的方式运行。它可能依赖于物理RAM和同时运行的其他程序，并且消耗更多或更少的内存。

WeakReference在Debug和Release中表现不同（未附加调试器）。即使使用工厂方法

2 个答案: