C# (.NET) 具有依赖于拥有对象的生命周期的对象

Question

我来自 C++ 背景，想听听 C# (.NET) 专家对以下问题陈述的一些想法，我愿意接受解决方法，但要求被冻结。

问题陈述：

1. 拥有一个系统，一旦拥有的对象被删除，就会自动清理依赖对象（与下面解释的 GC 提供的有点不同。）

2. 依赖对象可能有其他引用而不是其拥有对象，但一旦拥有对象被删除，依赖对象就需要离开

3. 能够用存根对象（占位符）引用替换其他未完成的引用，因为实际对象不再退出

4. 系统需要与对象无关，并且应该能够检测引用或用从 System.Object (.net) 继承的任何对象的存根替换它们

术语定义：

从属对象：始终需要所有者的对象，但也可能被其他对象引用。然而，依赖对象的生命周期将由拥有对象完全拥有。如果拥有对象被删除，则依赖对象必须被删除。

存根对象 这些是表示已删除引用的对象。

功能背景

为了能够支持功能需求，我们需要一个系统，该系统将自动清理所有者被删除的依赖对象，然后它会用存根替换其他引用以指示它所持有的对象已被删除或卸载,

用一个简单的例子来解释一下

1. Time T1 - 假设我们创建了一个 Line 对象。由于创建一条线需要一个起点和终点，因此它创建了 2 个点（Pt1 和 Pt2）对象。点对象被标记为从属对象，而线对象是所有者。所以在任何时候，如果我们删除 Line，它应该去删除 Pt1 和 Pt2。

2. 时间 T2：我们创建两个新点 Pt3 和 Pt4（它们现在是独立的对象）

3. 时间 T3：我们创建一个正在引用的曲线对象（Pt2、Pt3 和 Pt4）。这里 Pt2 的生命周期由 Line 对象控制。

4. 时间 T4：我们从图形中删除 Line 对象，现在作为一项要求，此操作必须删除 Pt1 和 Pt2，因为它们是由 Line 创建的，并且 Line 对象已被删除。

5. 时间 T5：由于曲线也引用了 Pt2，因此现在它的几何计算不完整，将参考存根对象。 Curve 对象将被标记为已损坏，以便在将来的某个时间点我们可以对其进行编辑以引用新点。

拥有这个系统的关键问题是因为删除是由.NET系统控制的，我们无法控制它。任何想法如何在 C# 或 .NET 中实现这一点（在 C++ 中，我们可以完全控制内存管理，因此可以在删除指针之前从指针确定活动引用并在内存中删除或替换它们）。

我了解垃圾收集器有其自身的巨大优势，但这是我们需要在基于 .NET 的 C# 模型中支持的关键要求。

任何想法，建议都表示赞赏。

Answer 1

通常，您无法控制 C# 中的内存释放。正如 Ameya 所建议的，你可以做的是有一个“脏”标志。

是的，我考虑过 Dirty field 方法，但正如我所说，这需要由系统级别管理。如果一个对象被标记为 Dirty 其他对象

请注意，在 .NET 中有很多类可以做到这一点：许多 IDisposable 类（尤其是从 Stream 继承的类！）当 Dispose()d 时，他们将 disposed 标志设置为 @ 987654326@，并在属性/方法中执行if (disposed) throw ObjectDisposedException()。在您的情况下，您不应该这样做，您应该简单地 return; 或 return (some default value);

public class ObjectWithReferences : IDisposable
{
    private List<ObjectWithReferences> childs;

    protected readonly ObjectWithReferences Parent;

    public bool IsDisposed { get; private set; }

    protected ObjectWithReferences(ObjectWithReferences parent)
    {
        Parent = parent;

        if (parent != null)
        {
            parent.AddChild(this);
        }
    }

    private void AddChild(ObjectWithReferences child)
    {
        if (IsDisposed)
        {
            child.Dispose();
            return;
        }

        if (childs == null)
        {
            childs = new List<ObjectWithReferences>();
        }

        childs.Add(child);
    }

    private void DisposeChilds()
    {
        if (childs == null)
        {
            return;
        }

        foreach (ObjectWithReferences child in childs)
        {
            if (!child.IsDisposed)
            {
                child.Dispose();
            }
        }

        childs = null;
    }

    public void Dispose()
    {
        if (!IsDisposed)
        {
            try
            {
                Dispose(true);
            }
            finally
            {
                try
                {
                    DisposeChilds();
                }
                finally
                {
                    IsDisposed = true;
                    GC.SuppressFinalize(this);
                }
            }
        }
    }

    ~ObjectWithReferences()
    {
        if (!IsDisposed)
        {
            try
            {
                Dispose(false);
            }
            finally
            {
                try
                {
                    DisposeChilds();
                }
                finally
                {
                    IsDisposed = true;
                }
            }
        }
    }

    protected virtual void Dispose(bool disposing)
    {
        // Does nothing, not necessary to call!
    }
}

使用示例：

public class ExampleRoot : ObjectWithReferences
{
    public ExampleRoot() : base(null)
    {
    }

    public void Foo()
    {
        if (IsDisposed)
        {
            return;
        }

        // Do Foo things
    }

    public void CreateChild()
    {
        if (IsDisposed)
        {
            return;
        }

        // Auto-adds itself!
        var child = new ExampleChild(this);
    }
}

public class ExampleChild : ObjectWithReferences
{
    private byte[] BigBuffer = new byte[1000000];

    public ExampleChild(ExampleRoot parent) : base(parent)
    {
    }

    protected override void Dispose(bool disposing)
    {
        // The ExampleChild object has a very long possible lifetime,
        // because it will live even in the IsDisposed == true state,
        // so it is better to free even managed resources.
        BigBuffer = null;
    }
}

代码非常简单/清晰...有两个示例类（Root 和Child）。基本思想是一个“特殊”对象ObjectWithReferences，它保留了其子对象的引用。它是IDisposable，当Dispose() 被调用（或当它最终确定时）它Dispose() 它的所有子对象。您可以使用您的类从该对象继承。您的每个方法/属性都应始终检查IsDisposed 属性以查看对象是否已被释放。如果它已被释放，它们应该什么都不做并返回默认值（0、null、string.Empty、...）。请注意，如果其中一个对象保留对大型托管对象（例如数组）的引用，则与建议的 .NET 准则相反，它应该 null 这些引用让 GC 收集它们。

请注意，将正在构建的对象添加到其父级的是构造函数！

Answer 2

这里的正常做法是使用WeakReference。

如果您需要自动存根行为，您可以执行以下操作：

public class AutoStubbed<T> where T:class
{
  private WeakReference<T> _reference;
  private T _stub;
  private readonly Func<T> _stubFactory;
  public AutoStubbed(T value, T stub)
  {
    _reference = new WeakReference<T>(value);
    _stub = stub;
  }
  public AutoStubbed(T value, Func<T> factory)
  {
    _reference = new WeakReference<T>(value);
    _stubFactory = factory;
  }
  public T Target
  {
    get
    {
      T ret;
      if(_reference.TryGetTarget(out ret))
        return ret;
      if(_stub == null && _stubFactory != null)
        _stub = _stubFactory();
      return _stub;
    }
  }
}

然后将T 输入到您的对象和存根定义的接口，而不是对象的类型。