1,托管堆基础
- 调用IL的newobj 为资源分配内存
- 初始化内存,设置其初始状态并使资源可用.类型的实列构造器负责设置初始化状态
- 访问类型的成员来使用资源
- 摧毁状态进行清理
- 释放内存//垃圾回收期负责.
2,从托管堆创造对象
- 进程初始化时候,CLR划出一个地址空间区域作为托管堆,并且初始化NextObjPtr指针,其指向下一个可用的托管堆地址.
- c#new操作 首先计算类型的字段所需要的字节数
- 加上对象开销的字节数:类型对象指针和同步块索引.64位机器上是16字节,32位机器是8字节.
- CLR检查是否空间够,如果够,则在指向地址处放入对象,并且将对象指针和同步块索引清0.接着,调用构造器.
3,垃圾回收算法
我们先来看垃圾回收的算法与主要流程：
算法：引用跟踪算法。因为只有引用类型的变量才能引用堆上的对象，所以该算法只关心引用类型的变量，我们将所有引用类型的变量称为根。
主要流程：
1.首先，CLR暂停进程中的所有线程。防止线程在CLR检查期间访问对象并更改其状态。
2.然后，CLR进入GC的标记阶段。
a. CLR遍历堆中的对象（实际上是某些代的对象，这里可以先认为是所有对象），将同步块索引字段中的一位设为0，表示对象是不可达的，要被删除。
b. CLR遍历所有根，将所引用对象的同步块索引位设为1，表示对象是可达的，要保留。
3.接着，CLR进入GC的碎片整理阶段。
a. 将可达对象压缩到连续的内存空间（大对象堆的对象不会被压缩）
b. 重新计算根所引用对象的地址。
4.最后，NextObjPtr指针指向最后一个可达对象之后的位置，恢复应用程序的所有线程。
重要提示:静态字段引用对象会一直存在.内存泄漏的常见原因是静态字段引用某个集合对象,然后不停添加数据项.因此,尽量避免使用静态变量.
4,垃圾回收和调试
public class GCRef
{
private static void TimerCallback(Object o)
{
Console.WriteLine("In TimerCallBack:" + DateTime.Now);
GC.Collect();
}
public static void Go()
{
Timer t = new Timer(TimerCallback, null, 0, 2000);
Console.ReadKey();
t.ToString();//使用该对象也可以使对象存活
t.Dispose();//使用显式垃圾回收的方式,进行垃圾回收.
}
}
由于进行垃圾回收,所以,只会回调一次该方法.当后面再使用方法的时候,才能够一致保存对象t.
5,垃圾回收的代的概念
- 对象越新,生存期越短
- 对象越老,生存期越长
- 回收堆的一部分,速度快于回收整个堆
- GC一个有3代0代,1代,2代
6,代的生成机制
- 初始化后,所有添加到堆中的对象都是0代.当0代对象操作某个预算容量的时候,进行垃圾回收.回收后剩下的,就是1代对象
- 重复上面的过程,然后1代对象不断的增加,知道其值超过某个预算容量,然后进行1代和0代的垃圾回收.1代剩余的到2代中;
- 1代剩余的对象到2代中,0代剩余的到1代中.0代清空.
7,GC.ReRegisterForFinalize(Object) 方法
public static class GCNotification
{
private static Action<int> s_gcDone = null; public static event Action<int> GCDone
{
add
{
if (s_gcDone == null) { new GenObject(0);new GenObject(2); }
s_gcDone += value;
}
remove
{
s_gcDone -= value;
}
}
private sealed class GenObject
{
private int m_generation;
public GenObject(int generation) { m_generation = generation; }
~GenObject()
{
if (GC.GetGeneration(this) >= m_generation)
{
Action<int> temp = Volatile.Read(ref s_gcDone);
if (temp != null) temp(m_generation);
} if ((s_gcDone != null) && (!AppDomain.CurrentDomain.IsFinalizingForUnload()) && (!Environment.HasShutdownStarted))
{
if (m_generation == 0) new GenObject(0);
else GC.ReRegisterForFinalize(this);
}
else { } //让对象被回收}
} }
public static void Go()
{
GCDone += x => Console.WriteLine($"GenObject {x}");
GC.Collect(); }
思路,1,自定义了事件,并且世界的通知对象类型是Action<int>,并且手动进行了触发.在垃圾回收的代>设定代m_generation时.
8,Finalization Queue和Freachable Queue-ReRegisterFinalize()和SupressFinalize()函数
一个将对象指针从Finalization队列中去除,一个重新加入到Finalization队列中.
这两个队列和.net对象所提供的Finalize方法有关。这两个队列并不用于存储真正的对象，而是存储一组指向对象的指针。当程序中使用了new操作符在Managed Heap上分配空间时，GC会对其进行分析，如果该对象含有Finalize方法则在Finalization Queue中添加一个指向该对象的指针。在GC被启动以后，经过Mark阶段分辨出哪些是垃圾。再在垃圾中搜索，如果发现垃圾中有被Finalization Queue中的指针所指向的对象，则将这个对象从垃圾中分离出来，并将指向它的指针移动到Freachable Queue中。这个过程被称为是对象的复生（Resurrection），本来死去的对象就这样被救活了。为什么要救活它呢？因为这个对象的Finalize方法还没有被执行，所以不能让它死去。Freachable Queue平时不做什么事，但是一旦里面被添加了指针之后，它就会去触发所指对象的Finalize方法执行，之后将这个指针从队列中剔除，这是对象就可以安静的死去了。.net framework的System.GC类提供了控制Finalize的两个方法，ReRegisterForFinalize和SuppressFinalize。前者是请求系统完成对象的Finalize方法，后者是请求系统不要完成对象的Finalize方法。ReRegisterForFinalize方法其实就是将指向对象的指针重新添加到Finalization Queue中。这就出现了一个很有趣的现象，因为在Finalization Queue中的对象可以复生，如果在对象的Finalize方法中调用ReRegisterForFinalize方法，这样就形成了一个在堆上永远不会死去的对象，像凤凰涅槃一样每次死的时候都可以复生。
public class MyFinalizeObject1//新建一个带终结器的会死灰复燃的类
{
public static int CountFinalized = 0;//类终结次数
public string Name { get; }//类名
public MyFinalizeObject1(string name)//类构造器
{ Name = name; }
public static void Go()
{
new MyFinalizeObject1("abc");
Timer t = new Timer(x => GC.Collect(), null, 0, 2000);
Console.ReadKey();
t.Dispose();
}
~MyFinalizeObject1()//将在Finalization Queue队列中的类首先放入 Freachable Queue中,然后调用终结器,然后再释放.
{
Console.WriteLine(this.GetType().ToString() + $" {this.Name} has been DC {CountFinalized++}");//类每次终结输出信息
GC.ReRegisterForFinalize(this);//将类重新放入终结队列.
}
}
在GO中创建一个Threading.TImer对象,让其每2秒实行一次垃圾显示回收
ClrFromCSharp_2_2.LearnGC.MyFinalizeObject1 abc has been DC 0
ClrFromCSharp_2_2.LearnGC.MyFinalizeObject1 abc has been DC 1
ClrFromCSharp_2_2.LearnGC.MyFinalizeObject1 abc has been DC 2
9,垃圾回收模式:
- 工作站:针对客户端优化,GC造成延迟很低
- 服务器:托管堆被分配到每个CPU一个GC,每个GC负责各自区域,并且在每个CPU上面运行特殊的线程:并发回收垃圾.
- 配置文件告诉使用服务器回收器
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<probing privatePath="AuxFiles"/>//在哪个位置寻找程序集.
</assemblyBinding>
<gcServer enabled="true"/>
</runtime>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2"/>
</startup>
</configuration>
public class MyFinalizeObject1//新建一个带终结器的会死灰复燃的类
{
public static int CountFinalized = 0;//类终结次数
public string Name { get; }//类名
public MyFinalizeObject1(string name)//类构造器
{ Name = name; }
public static void Go()
{
new MyFinalizeObject1("abc");
Console.WriteLine($"{GCSettings.IsServerGC}");//查看是否启用了服务器垃圾回收
Timer t = new Timer(x => GC.Collect(), null, 0, 2000);
Console.ReadKey();
t.Dispose();
}
~MyFinalizeObject1()//将在Finalization Queue队列中的类首先放入 Freachable Queue中,然后调用终结器,然后再释放.
{
Console.WriteLine(this.GetType().ToString() + $" {this.Name} has been DC {CountFinalized++}");//类每次终结输出信息
GC.ReRegisterForFinalize(this);//将类重新放入终结队列.
}
}
子模式:
- 并发:占用更多资源,创建了额外的后台线程
- 非并发----可以设定配置
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<probing privatePath="AuxFiles"/>
</assemblyBinding>
<gcServer enabled="true"/>//设定服务器模式
<gcConcurrent enabled="false"/>//设定非并发模式
</runtime>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2"/>
</startup>
</configuration>
自定义在低回收延迟模式进行绘画,动画等低延迟操作
private static void LowLatencyDemo()
{
GCLatencyMode OldMode = GCSettings.LatencyMode;
System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
try
{
GCSettings.LatencyMode = GCLatencyMode.LowLatency;
//自己的代码,低GC回收延迟
}
finally
{
GCSettings.LatencyMode = OldMode;
}
}
10-,强制垃圾回收GC.Collect(int Generation,GCCollectionMode mode,bool blocking)
11,监视应用程序内存:
11.1 在内存中使用函数
~MyFinalizeObject1()//将在Finalization Queue队列中的类首先放入 Freachable Queue中,然后调用终结器,然后再释放.
{
Console.WriteLine(this.GetType().ToString() + $" {this.Name} has been DC {CountFinalized++}");//类每次终结输出信息
Console.WriteLine($"CollectionCount:{GC.CollectionCount(0)}");
Console.WriteLine($"GetTotalMemery:{GC.GetTotalMemory(false)}");
GC.ReRegisterForFinalize(this);//将类重新放入终结队列.
}
11.2打开性能监视器---PerfMon.exe
然后查看+,添加.net clr memeroy,勾选显示描述.
12.使用需要特殊清理的类型.任何包含本机资源的类型都支持终结---Finalize
文件,网络连接,套接字,互诉体---都支持.
------------创建本机的托管资源类型时,强烈建议应该从System.Runtime.InteropServices.SafeHandle这个基类来进行派生.
[System.Security.SecurityCritical]
public abstract class SafeHandle : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, IDisposable
该类的实现:
protected SafeHandle (IntPtr invalidHandleValue, bool ownsHandle);
参数
invalidHandleValue
IntPtr
无效句柄的值（通常为 0 或 -1）。 IsInvalid 的实现应对此值返回 true。
ownsHandle
Boolean
在终止阶段使 true 可靠地释放句柄，则为 SafeHandle；否则为 false（不建议使用）。
注解
如果 ownsHandle 参数 false，则永远不会调用 ReleaseHandle;因此，不建议使用此参数值，因为代码可能会泄漏资源。
//也就是说,invalidHandleValue,只是无效的Handle的值.此时,IsInvalid返回true;
另一个参数建议true,否则无法使用RelseaseHandle()函数,该函数用于释放资源.
public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
{//只是本机资源句柄.
protected IntPtr handle;
//第二个参数指明,派生的对象被回收时,本机资源也被关闭.true---调用ReleaseHandle()函数.
protected SafeHandle(IntPtr invalidHandlerValue, bool ownsHandle)
{
this.handle = invalidHandlerValue;
}//第一个参数指明非实句柄的值0或-1,第二个指明,是否自定义释放句柄函数工作.
protected void SetHandle(IntPtr handle)
{
this.handle = handle;
}
public void Dispose() { Dispose(true); }
protected virtual void Dispose(Boolean disposing)
{
//默认实现忽略disposing参数
//如果资源已经释放,那么返回.
//如果ownsHandle为false,那么返回.
//设置 标志位 来只是资源已经释放
//调用虚方法 ReleaseHandle();
//调用GC.SuppressFinalize(this)阻止调用Finalize方法
//如果ReleaseHandle返回true,那么返回.
//如果走到这一步,激活releaseHandleFaild托管调试助手(MDA)
}
~SafeHandle() { Dispose(false); }
protected abstract bool ReleaseHandle();//必须重写这个方法以实现释放资源代码 public void SetHandleAsInvalid()
{
//调用GC.SuppressFinalize(this)方法来阻止调用Finalize方法.
}
public bool IsClosed
{
get { return true; } //返回指出资源是否释放的标志---Dispose(true)中设置.
}
public abstract bool IsInvalid//重写该属性,只是句柄值不代表资源,0或-1.
{
get;
}
}
safeHandle派生的类有:
- SafeHandle 是操作系统句柄的抽象包装器类。 从此类派生比较困难。 但可以使用 Microsoft.Win32.SafeHandles 命名空间中可提供以下项的安全句柄的派生类。
- 文件（SafeFileHandle 类）。
- 内存映射文件（SafeMemoryMappedFileHandle 类）。
- 管道（SafePipeHandle 类）。
- 内存视图（SafeMemoryMappedViewHandle 类）。
- 加密构造（SafeNCryptHandle、SafeNCryptKeyHandle、SafeNCryptProviderHandle和 SafeNCryptSecretHandle 类）。
- 进程（SafeProcessHandle 类）。
- 注册表项（SafeRegistryHandle 类）。
- 等待句柄（SafeWaitHandle 类）。
以下是SafeHandleZeroOrMinusOneIsInvalid
//从 SafeHandle 派生的类---SafeHandleZeroOrMinusOneIsInvalid:SafeHandle public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
{
protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle) : base(IntPtr.Zero, ownsHandle) { }//默认设定句柄为0.
public override bool IsInvalid//只是句柄为0,或者-1时候,则为Invalid形式.
{
get
{
if (base.handle == IntPtr.Zero) return true;
if (base.handle == (IntPtr)(-1)) return true;
return false;
}
}
}
以下是SafeFileHandle类
public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
{
public SafeFileHandle(IntPtr preExistingHandle,bool ownsHandle) : base(ownsHandle) { base.SetHandle(preExistingHandle); }
protected override bool ReleaseHandle()
{
return Win32Native.CloseHandle(base.handle);
}
}
13,使用包装了本机资源的类型
假定写代码创建一个临时文件,向其中写入一些字节,然后删除文件.会报出IOException错误,因为,在文件资源生存期无法删除此文件.
public class CallSafeHandle
{
public static void Demo1()
{
byte[] bytes = { 1, 2, 3, 4, 5 };
FileStream fs = new FileStream("Temp.dat", FileMode.Create);
fs.Write(bytes, 0, bytes.Length);
File.Delete("Temp.dat"); }
}
将代码更改为如下----添加了,dispose();就可以正常运行了.
byte[] bytes = { 1, 2, 3, 4, 5 };
FileStream fs = new FileStream("Temp.dat", FileMode.Create);
fs.Write(bytes, 0, bytes.Length);
fs.Dispose();
File.Delete("Temp.dat");
注意:Dispose()函数只是释放资源,但是对象还是存在的.
public static void Demo1()
{
byte[] bytes = { 1, 2, 3, 4, 5 };
FileStream fs = new FileStream("Temp.dat", FileMode.Create);
try
{
fs.Write(bytes, 0, bytes.Length);
}
finally
{
if (fs != null) fs.Dispose();
} File.Delete("Temp.dat"); }
可以ji进一步更改为如下的形式 使用using.
public static void Demo1()
{
byte[] bytes = { 1, 2, 3, 4, 5 }; using(FileStream fs = new FileStream("Temp.dat", FileMode.Create))//相当于 Try...Finally结构,必须实现IDispose接口
{
fs.Write(bytes, 0, bytes.Length);
} File.Delete("Temp.dat");
}
利用 StreamWriter 进行文件读写操作.
public static void Demo2()
{
using(StreamWriter sw=new StreamWriter(new FileStream("DataFile.txt", FileMode.OpenOrCreate)))
{
sw.Write("Hi there");
} }
}
注意:StreamWrite只会把数据写入到缓冲区里面,所以需要Dispose()函数才能真正写入进去.或者调用Flush().
14,GC的其他功能----使用这个来防止以下的情况:
1,托管类很小,资源类很大,比如位图,这样会造成内存用量很大.使用这个,可以提示GC提前,并且更频繁的进行垃圾回收.
- GC.AddMemoryPressure(int64 byteallocated)
- GC.RemoveMemoryPressure(Int64 byteallocated)
private sealed class BigNativeResource
{
private int m_size;
public BigNativeResource(int size)
{
if (m_size > 0) GC.AddMemoryPressure(m_size);//每个类提示实际消耗内存.
Console.WriteLine("BigNativeResource create.");
}
~BigNativeResource()
{
if (m_size > 0) GC.RemoveMemoryPressure(m_size);//每个类提示实际取消内存.
Console.WriteLine("BigNativeResource destroy.");
}
}
2,设定有限制的资源----使用HandleCollector这个类的问题.
private sealed class LimitedResource
{
private static readonly HandleCollector s_hc = new HandleCollector("LimitedResource", 2);
public LimitedResource()
{
s_hc.Add();
Console.WriteLine($"LimitedResource create {s_hc.Count}");
}
~LimitedResource()
{
s_hc.Remove();
Console.WriteLine("LimitedResource destroy. Count={0}", s_hc.Count);
}
}
控制一个Handle Collector,并且初始化为2,也就是说只要该对象增加值达到2个,就开始垃圾回收.
HandleCollectorDemo
LimitedResource create 1
LimitedResource create 2
LimitedResource create 3
LimitedResource create 4
LimitedResource destroy. Count=4
LimitedResource destroy. Count=3
LimitedResource destroy. Count=2
LimitedResource destroy. Count=1
LimitedResource create 1
LimitedResource create 2
LimitedResource create 3
LimitedResource create 4
LimitedResource destroy. Count=4
LimitedResource destroy. Count=3
LimitedResource destroy. Count=2
LimitedResource create 3
LimitedResource create 3
LimitedResource destroy. Count=2
LimitedResource destroy. Count=1
LimitedResource destroy. Count=0
程序中改成了4个对象.也就是该类,通过控制数量来触发垃圾回收.
15,终结的工作原理:
有终结器的对象在垃圾回收的时候,从 Finalization Queue移动到Freachable Queue,然后执行Finalize方法,然后,在清空Freachale队列.所以,对于某个有终结器的对象,其有可能要求不止进行2次垃圾回收.
16,手动监视和控制对象的生存期----CLR为每个AppDomain都提供了一个GC句柄表(GC Handle table)---该表使用
GCHandle类在表中添加删除记录项.
GCHandle 结构与 GCHandleType 枚举一起使用，以创建对应于任何托管对象的句柄。 此句柄可以是以下四种类型之一： Weak、WeakTrackResurrection、Normal或 Pinned。 如果分配了句柄，则在非托管客户端持有唯一引用时，可以使用它来防止垃圾回收器收集托管的对象。 如果没有这样的句柄，则在代表非托管客户端完成其工作之前，垃圾回收器可以收集该对象。
你还可以使用 GCHandle 来创建一个固定的对象，该对象返回内存地址以防止垃圾回收器将对象移动到内存中。
public struct GCHandle
{
public static GCHandle Alloc(object value);
public static GCHandle Alloc(object value, GCHandleType type);
//静态方法,用于将一个GCHandle-->IntPtr
public static explicit operator IntPtr(GCHandle value);
public static IntPtr ToIntPtr(GCHandle value);
//静态方法,用于比较两个GCHandle
public static bool operator ==(GCHandle a, GCHandle b);
public static bool operator !=(GCHandle a, GCHandle b);
//实列方法,用于释放表中的记录项,索引设为0---也就是将IntPtr设为0
public void Free();
//实列属性,用于获得记录项对象
public object Target { get; set; }
//判断索引是否被分配.索引不为0则返回true
public bool IsAllocated { get; }//调用Alloc 为true,调用Free,为False
//对于已固定记录项,这个方法返回对象地址
public IntPtr AddOfPinnedObject(); }
GCHandleType 有以下四个类型:
- Weak:允许监视生存期,Finalize对象可能执行,可能没执行.
- WeakTrackResurrection
:允许监视生存期,Finalize对象已执行.对象内存已回收 Normal:允许控制对象生存期(默认).该对象必须在内存里,垃圾回收时,可以移动.Pinned:允许控制对象生存期(默认).该对象必须在内存里,垃圾回收时,不可移动,对象在内存中地址固定.
垃圾
回收流程:
| 1 | GC标记所有可达对象,然后扫描GC句柄表,然后所有Normal和Pinned的记录项被看成根,所有的相关对象变为可达.不进行回收. |
| 2 |
GC扫描句柄表中Weak记录项,如果其对象不可达,则将该记录项的引用值改为null. 在终结器运行之前， |
| 3 | GC扫描终结列表,将终结列表对象(带析构函数的类的对象)移动到freachable队列中,并且这些对象被标记,变成可达对象. |
| 4 |
GC扫描GC句柄表WeakTrackResurrection记录项.如果其对象不可达,则记录项引用值更改为NULL 该句柄类型类似于 Weak，但如果对象在终结过程中复活，此句柄不归零。 |
| 5 |
GC进行内存压缩,Pinned对象不会被移动 |
GCHandle 使用情况-----Normal和Pinned入手
使用 GCHandle.Alloc 方法注册对象,然后将返回的GcHandle实列转换为IntPtr...再将这个指针传递给本机代码.
本机代码回调托管代码时,托管代码将传递的IntPtr转型为GCHandle,然后,查询其Target属性来获得托管对象的引用.
本机代码不需要时,可以使用GCHandle.Free使其注销.
使用Fixed…使垃圾回收的时候
unsafe public static void Demo1()
{
for (int x = 0; x < 10000; x++) new object();
IntPtr orgptr;
byte[] bytes = new byte[1000];
fixed(Byte* p = bytes)//告诉GC不要移动该对象.
{
orgptr = (IntPtr)p;
}
GC.Collect();
fixed(byte* p = bytes)//告诉GC不要移动该对象.
{
Console.WriteLine(orgptr == (IntPtr)p ? "Yes" : "NO");
}
}
}
使用该关键字使得指向的对象地址固定,不被GC移动.(指针指向的对象地址必须固定)
Weak Reference<T>---
方法
| Equals(Object) |
确定指定对象是否等于当前对象。 (继承自 Object) |
| Finalize() |
丢弃对当前 |
| GetHashCode() |
用作默认哈希函数。 (继承自 Object) |
| GetObjectData(SerializationInfo, StreamingContext) |
用序列化当前 |
| GetType() |
获取当前实例的 (继承自 |
| MemberwiseClone() |
创建当前 (继承自 |
| SetTarget(T) |
设置 |
| ToString() |
返回表示当前对象的字符串。 (继承自 Object) |
| TryGetTarget(T) |
尝试检索当前 |
本质是一个GCHandle包装器.其构造器调用Alloc方法.SetTarget设定Target对象.TryGetTarget用于获取Target对象.
终结器调用Free方法.
WeakReference<T>含义是,对于对象的引用时弱引用.也就是,其并不会阻止GC回收该对象.
public static void Go()
{
ObjectA objA = new ObjectA("objA"); WeakReference<ObjectA> weakReference = new WeakReference<ObjectA>(objA);
ShowObject(weakReference);
// weakReference.TryGetTarget(out ObjectA objectA1);
objA = null;
//objectA1 = null; 注释的时候,显示对象没有被回收,因为有引用,是能这句的时候,对象没有引用,所以下面的没有了.
// GC.Collect(); ShowObject(weakReference); }
没有进行垃圾回收,显示
obj1 is Exsit!
obj1 is Exsit!
有进行垃圾回收显示
obj1 is Exsit!
obj1 is not exsist!(垃圾回收后,该对象不存在了).
17.使用ConditionalWeakTable
[System.Runtime.InteropServices.ComVisible(false)]
public sealed class ConditionalWeakTable<TKey,TValue> where TKey : class where TValue : class
public static void GO()
{
var mc1 = new ManagedClass();
var mc2 = new ManagedClass();
var mc3 = new ManagedClass(); var cwt = new ConditionalWeakTable<object, ClassData>();
cwt.Add(mc1, new ClassData());
cwt.Add(mc2, new ClassData());
cwt.Add(mc3, new ClassData()); var wr2 = new WeakReference(mc2);
mc2 = null; GC.Collect();
Print(wr2.Target, cwt);
var b1= wr2.Target != null;
//if (b1) Console.WriteLine("aaa");//注意,在if 语句里面,似乎这个弱引用被使用了???
}
class ManagedClass
{
} class ClassData
{
public DateTime CreationTime;
public object Data; public ClassData()
{
CreationTime = DateTime.Now;
this.Data = new object();
}
}
private static void Print(object Target, ConditionalWeakTable<object, ClassData> cwt)
{
ClassData data = null; if (Target == null)
Console.WriteLine("No strong reference to mc2 exists.");
else if (cwt.TryGetValue(Target, out data))
Console.WriteLine("Data created at {0}", data.CreationTime);
else
Console.WriteLine("mc2 not found in the table.");
}
}
-------这里有个关键问题.似乎在if中使用wr2,则这个对象不会被收集,所以,需要尽量在函数中使用wr2,否则其可能还存在.
No strong reference to mc2 exists.
答案2:如果If语句没有被注释.
Data created at 2020/2/12 19:59:41
aaa