C#中的弱引用和强引用

今天在看CommunityToolkit.Mvvm包里的消息这一块时，发现内部实现使用了ConditionalWeakTable<TKey,TValue>这个类，查了一下资料，发现这个类是弱引用 相关的。

这个做个完整的总结，防止以后忘记。

 

强引用(strong reference）

什么叫强引用，简单来说，就是保持对象的可访问性，防止被垃圾回收(GC)。这里指的可访问性，是指该对象正由程序使用中。

 

弱引用(weak reference)

弱引用允许应用程序访问对象，同时也允许垃圾回收相应的对象。 如果不存在强引用，则弱引用的有限期只限于收集对象前的一个不确定的时间段。

简单点说，就是将一个对象声明成弱引用后，下次你去访问时，有可能访问得到（没有被垃圾回收），有可能访问不到（已经被垃圾回收掉了）。

占用大量内存，但通过垃圾回收功能回收以后很容易重新创建的对象特别适合使用弱引用。

 

短弱引用和长弱引用 

短弱引用

垃圾回收功能回收对象后，短弱引用的目标会变为 null。 弱引用本身是托管对象，与其他任何托管对象一样需要经过垃圾回收。 短弱引用是 WeakReference 的无参数构造函数。

 

长弱引用

在对象的 Finalize 方法已调用后，长弱引用获得保留。 这样，便可以重新创建该对象，但该对象仍保持不可预知的状态。 如果要使用长引用，在 WeakReference 构造函数中指定为true。

如果对象类型不包含 Finalize 方法，应用的是短弱引用功能。弱引用只在目标被收集前有效，运行终结器后可以随时收集目标。

长引用这里我其实不是很理解 ，直到我看到了这个链接

https://stackoverflow.com/questions/15120942/any-practical-example-of-long-weak-reference

 

WeakReference和WeakReference<T>

弱引用主要通过WeakReference和WeakReference<T>两种类型实现。两者的区别是WeakReference<T>可以指定类型，WeakReference不能指定类型。

 

下面通过一个示例，来演示一下，如何使用弱使用。

 

首先定义一个数据类(Data)，用于存储数据，构造函数可以指定数据大小。

/// <summary>
/// 字节数据类
/// </summary>
public class Data
{
    private byte[] data;   //字节数据  这个字段实际没有用到，只是为了模拟大量数据
    private string name;   //名称 返回size

    public Data(int size)
    {
        data = new byte[size * 1024];
        name = size.ToString();
    }

    public string Name
    {
        get { return name; }
    }
}

 

再定义一个缓存类（Cache）

这个缓存类里有一个缓存字典，Key是数字，Value是一个WeakReference对象。

在构造函数里，指定数量，初始化字典，以及创建对应的弱引用。

通过索引器方法来取字典里的值

/// <summary>
/// 缓存类
/// </summary>
public class Cache
{
    // 缓存字典
    static Dictionary<int, WeakReference> cache;

    // 重新创建的个数
    int regenCount = 0;

    public Cache(int count)
    {
        cache = new Dictionary<int, WeakReference>();

        //创建指定数量的弱引用
        for (int i = 0; i < count; i++)
        {
            cache.Add(i, new WeakReference(new Data(i), false));
        }
    }

    /// <summary>
    /// 缓存数量
    /// </summary>
    public int Count
    {
        get { return cache.Count; }
    }

    /// <summary>
    /// 需要重新创建的对象个数
    /// </summary>
    public int RegenerationCount
    {
        get { return regenCount; }
    }

    /// <summary>
    /// 从缓存获取数据
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    public Data this[int index]
    {
        get
        {
            Data d = cache[index].Target as Data;
            if (d == null)
            {
                // 如果对象已经被回收了，重新创建一个
                Console.WriteLine("索引 {0}: 的数据需要重新创建", index);
                d = new Data(index);
                cache[index].Target = d;
                regenCount++;
            }
            else
            {
                // 通过弱引用获取对象，不需要重新创建
                Console.WriteLine("索引 {0}: 的数据不需要重新创建", index);
            }

            return d;
        }
    }
}

 

测试代码：

创建一个数量为50的缓存，然后循环，随机访问缓存里的数据，

输出缓存里的数据是否需要重新创建，以及重新创建的比例

public class Program
{
    public static void Main()
    {
        //假设缓存数量为50
        int cacheSize = 50;

        Random r = new Random();
        Cache c = new Cache(cacheSize);

        string DataName = "";
        GC.Collect(0);

        // 随机从缓存中取数据
        for (int i = 0; i < c.Count; i++)
        {
            int index = r.Next(c.Count);

            // 访问对象的属性值
            DataName = c[index].Name;
        }
        
        //输出结果
        double regenPercent = c.RegenerationCount / (double)c.Count;   //对象重新创建的比例
        Console.WriteLine("缓存数量: {0}, 重新创建的比例: {1:P2}", c.Count, regenPercent);
    }
}

 

运行结果

 

示例代码

 

推荐阅读：

https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/