如何阻止对象（以及其中的所有内容）最终确定？

Question

在我为期两周的解决问题的过程中：

• How to get notified before static variables are finalized
• Unload event for the default Application Domain?
• Profiling ASP.net applications over the long term?

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

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

我需要一种方法来告诉垃圾收集器不要动手。

有没有办法防止对象被终结？

例如

例如，下面的代码是错误的，因为终结器错误地认为私有_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 本身还没有最终确定，垃圾收集器也可能对_values 执行不需要的labotomy。

使用 GCAlloc.Alloc()

@MatthewWatson 有一个绝妙的主意。我认为指出为什么它是错误的会很有用。使用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
      }
   }
}

注意：它也可能由于伪记录行为而失败。来自The Truth About GCHandles：

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

强调我的。

那就对了。我需要告诉垃圾收集器

不要最终确定这个对象（以及其中的所有内容）

棘手的部分是我不拥有的类的内部私有成员；即使是仍然被GCAlloc 引用的对象，其背后仍然有它所依赖的对象。

示例用法

public static Foo
{
   public static Sqm = new Sqm();
}

Foo.Sqm.AddSample("QueryCustomerInfo", stopwatch.TotalMicroseconds);

Answer 1

无论如何，在最终确定期间执行任何长期操作（例如输入输出）都是一种非常糟糕的做法。 您应该考虑将对象的 _values 列表存储在静态列表中 - 这将防止值被破坏。当您的对象正在完成时，您可以将对内部列表的引用保存在另一个静态列表中，该列表会定期检查。当它包含对列表的引用时，这意味着您的对象已被破坏并且它包含的值应该被保存。

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);
  }
}

UPD.：如果域可能在您不希望的情况下被关闭，您唯一的方法是将值存储在另一个域中。