如何阻止一个对象（以及它里面的一切）被最终确定？

Question

在我长达两周的寻求解决一个问题的过程中：

null

有什么方法可以防止对象被最终确定吗？

例如，下面的代码有缺陷，因为终结器错误地表示私有_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);
   }
}

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

@MatthewWatson有个好主意。我想指出为什么它是错误的是有用的。使用gcalloc.alloc保存对对象的引用。然后在终结器期间使用can访问它：

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之前，该条目一直保持不变。

棘手的部分是我不拥有的班级的内部私人成员；即使一个仍然被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);
  }
}

如果域可能在你不想关机的时候关机，你唯一的方法是将值存储在另一个域中。