在我长达两周的解决问题的探索中：

• 如何在静态变量最终确定之前得到通知
• 是否卸载默认应用程序域的事件
• 长期分析ASP.net应用程序

根本问题是垃圾收集器。当对象即将释放（即回收其资源）时，我的对象的Finalizer将是做出反应的理想时间。.NET垃圾收集系统的问题是，当my终结器被调用时，我拥有的其他对象很可能已经被终结。

如果我与本机类对象进行互操作，那么这个问题将很难解决。垃圾收集器无法在我背后释放这些对象（并且未经我的许可）。因此，当调用托管对象的终结器时，我知道我的内部状态仍然有效。

我需要的是告诉垃圾收集器不要插手。

有没有办法防止一个对象最终确定？

例如

例如，下面的代码有缺陷，因为终结器错误地认为私有_values对象仍然存在。事实上，它很可能已经在我的领导下敲定了：

class Sqm
{
   private List<Value> _values = new List<Value>();
   //finalizer
   public ~Sqm()
   {
       Shutdown();
   }
   protected void Shutdown()
   {
      foreach (var value in _values)  //<-- crash; _values no longer exists
         SaveValueToHardDrive(value); //<-- crash; value no longer exists
   }
}

我需要的是告诉垃圾收集器不要完成该列表对象或其中的任何对象：

class Sqm
{
   private List<Value> _values = new List<Value>();
   //constructor
   public Sqm()
   {
      GC.LetMeManuallyFinalize(_values);
   }
   //finalizer
   public ~Sqm()
   {
       Shutdown();
       GC.ManuallyFinalize(_values);
   }
   protected void Shutdown()
   {
      foreach (var value in _values) 
         SaveValueToHardDrive(value);
   }
}

这可能有两个问题：

• 没有GC.ManuallyFinalize方法

• 它可能会抑制释放_values列表本身，但它引用的对象可能仍然会在我背后完成：

    protected void Shutdown()
    {
       foreach (var value in _values) 
          SaveValueToHardDrive(value); //<---crash, contained object already finalized
    }
  

因此，现在我需要确保添加到列表中的对象也被排除在最终确定之外：

public void AddSample(String name, Int64 value)
{
    Entry entry = GetEntryByName(name);
    if (entry == null)
    {
       entry = new Entry();
       GC.LetMeManuallyFinalize(entry);
    }
    entry.Count += 1;
    entry.Sum += value;
    entry.Average = entry.Sum / entry.Count;
}
//finalizer
public ~Sqm()
{ 
   foreach (var value in _values)
      GC.ManuallyFinalize(value);
   GC.ManuallyFinalize(_values);      
}

这可能有一个问题，即虽然Entry没有其他内部对象，但我不知道List<T>。垃圾收集器可能会对_values执行不需要的Laboration，即使_values本身尚未最终确定。

使用GCAlloc.Alloc（）

@马修·沃森有一个绝妙的主意。我认为指出错误的原因会很有用。使用GCAlloc.Alloc保存对对象的引用。然后你可以在你的终结器中访问它：

public Sqm()
{
   private List<Value> _values = new List<Value>();
   private GCHandle _valuesHandle; //handle to keep _values alive
   //constructor
   Sqm()
   {
      //prevent _values from being finalized
      _valuesHandle = GCAlloc.Alloc(_values); 
   }
   //finalizer
   ~Sqm()
   {
      try
      {
         Shutdown(_values); //Safe, right? RIGHT? _values couldn't have been finalized
      } 
      finally
      {
         _valuesHandle.Free();
      }
   }
   private void Shutdown(List<Values> values)
   {
      foreach (var value in values)
      {
         //The list itself might not have been finalized
         //But objects used internally to Microsoft's List<T> class have been finalized
         //and objects in the list itself were already finalized
         SaveValueToHardDrive(value); //<--BAD: values inside list were already finalized
      }
   }
}

注意：它也可能因为伪文档化的行为而失败。关于GCHandles:的真相

创建新的GCHandle时，将在AppDomain的句柄表中创建一个新条目。此条目一直保留到释放句柄（通过GCHandle.Free()）或卸载AppDomain。

强调我的。

所以这是正确的。我需要告诉垃圾收集器

不要完成此对象（及其内部的所有东西）

棘手的部分是我不拥有的班级的内部私人成员；即使是仍然被CCD_ 11引用的对象，其所依赖的对象仍将在背后最终确定。

示例用法

public static Foo
{
   public static Sqm = new Sqm();
}
Foo.Sqm.AddSample("QueryCustomerInfo", stopwatch.TotalMicroseconds);

class Sqm
{
  private static List<List<Value>> = _lists = new List<List<Value>>();
  private static List<List<Value>> = _finalizationQueue = new List<List<Value>>();
  private List<Value> _values = new List<Value>();
  Sqm() { _lists.Add(_values); }
  ~Sqm() { _finalizationQueue.Add(_values); }
  public static void CheckAndSave()
  {
    foreach(var list in _finalizationQueue)
      SaveValues(list);
  }
}