C# 一次性对象

Question

关于如何处理 IDisposable 对象序列，是否有一些建议？

例如，我有一个构建 IEnumerable 序列的方法， 在某些时候，我需要手动处理这些对象，因为否则这可能会导致一些泄漏。

现在，有没有办法将 Dispose() 调用绑定到垃圾收集器操作，因为我希望这些对象在其他代码不再访问时立即被处置部分？

**或者也许你可以建议我一些其他方法？ **

---

一般来说，这似乎是同样的问题，例如，在没有 的非托管 C++ 中>共享指针，您可以在其中拥有一个方法：

SomeObject* AllocateAndConstruct();

然后，如果您不使用代码契约或不在注释中说明某些内容，则无法确定何时处置它。

我想一次性物品的情况也差不多，但我希望有一个合适的解决方案。

Answer 1

（来自问题）

现在有没有办法绑定
Dispose() 调用垃圾收集器
动作，因为我想要这些对象
就在他们被安排的那​​一刻
无法再从其他代码访问
零件？

当您的对象超出范围/范围时，GC 不会立即发生；它是不确定的。当 GC 看到它时，没有必要做任何其他事情（终结器尚未处理），因为为时已晚。

那么，诀窍就是知道何时完成，并自己调用Dispose()。在许多情况下，using 可以实现这一点。例如，您可以编写一个实现 IDisposable 并封装一组 Image 的类 - 并使用 using 包装对该封装对象的使用。包装器上的 Dispose() 可以 Dispose() 所有保存的图像。

但是

using(var imageWrapper = GetImages()) {
    foreach(var image in imageWrapper) {
         ...
    }
    // etc
} // assume imageWrapper is something you write, which disposes the child items

，如果您在 UI 上显示数据，这会有点棘手。那里没有捷径；您必须跟踪完成每个图像的时间，或者接受非确定性的最终确定。

Answer 2

如果您想明确地处置集合中的对象，则应该对每个对象调用 Dispose：

myImages.ToList().ForEach(image => image.Dispose());

如果您不这样做，并且您的对象变得无法访问，GC 最终将运行并释放它们。

现在，如果您不想手动编写 Dispose 调用代码，则可以创建一个实现 IDisposable 的包装类，并通过 using 使用它> 声明：

using (myImages.AsDisposable()) { 
  // ... process the images
}

这是所需的“基础设施”：

public class DisposableCollectionWrapper<D> : IDisposable
where D : IDisposable {

  private readonly IEnumerable<D> _disposables;

  public DisposableCollectionWrapper(IEnumerable<D> disposables) {
    _disposables = disposables;
  }

  public void Dispose() {
    if (_disposables == null) return;
    foreach (var disposable in _disposables) {
      disposable.Dispose();
    }
  }

}

public static class CollectionExtensions {

  public static IDisposable AsDisposable<D>(this IEnumerable<D> self)
  where D : IDisposable {
    return new DisposableCollectionWrapper<D>(self);
  }

}

另请注意，这与您用 C++ 描述的情况不同。在 C++ 中，如果您不删除对象，就会出现真正的内存泄漏。在 C# 中，如果您不释放对象，垃圾收集器最终将运行并清理它。

Answer 3

您应该以一种您知道何时不再需要资源的方式来设计系统。在最坏的情况下，当垃圾收集器到达它们时，它们最终将被处置，但 IDisposable 的要点是您可以更早地释放重要资源。

这个“更早”由您来定义，例如，您可以在使用它们的窗口关闭时，或者当您的工作单元完成对它们执行的任何操作时释放它们。但在某些时候，某个对象应该“拥有”这些资源，因此应该知道何时不再需要它们。

Answer 4

您可以使用“using”块，以确保在离开该块后立即释放 IDisposable。编译器确实将此类块封装到 try - finally 语句中，以确保在离开该块时在任何情况下都会调用 Dispose。

通过使用终结器，可以使 GC 对那些以某种方式“丢失”的对象调用 Dispose 方法。然而，实现终结器的成本更高，并且会降低垃圾收集效率，并可能降低应用程序的整体性能。因此，如果可能的话，您应该尽量确保自己处理 IDisposables；确定性：

public class Context : IDisposable {

    List<IDisposable> m_disposable = new List<IDisposable>();
    public void AddDisposable(IDisposable disposable) {
        m_disposable.Add(disposable); 
    }

    public void Dispose() {
        foreach (IDisposable disp in m_disposable)
            disp.Dispose(); 
    }

    // the Context class is used that way: 
    static void Main(string[] args) {

        using (Context context = new Context()) {
            // create your images here, add each to the context
            context.AddDisposable(image); 
            // add more objects here 

        } // <- leaving the scope will dispose the context
    }
}

通过使用一些巧妙的设计，将对象添加到上下文的过程可能会变得更加容易。人们可以为创建方法提供上下文或通过静态单例发布它。这样，它也可用于子方法范围 - 无需传递对上下文的引用。通过利用该方案，甚至可以模拟 C++ 中已知的人工析构函数功能。

Answer 5

简洁的方法是创建您自己的实现 IDisposable 的通用集合类。当这个集合类被 Dispose() 时，询问每个元素是否实现了 IDispose，如果是，则将其处理掉。

示例（如果您不知道 IDisposable 模式，请查看其他地方）

public class MyDisposableList<T> : List<T> : IDisposable
{
    private bool disposed = false;

    ~MyDisposableList()
    {
        Dispose(false);
    }

    public void Dispose()
    {
        Dispose(true);
    }

    protected void Dispose(bool disposing)
    {
        if (!disposed)
        {
            foreach (T myT in this)
            {
                IDisposable myDisposableT = myT as IDisposable;
                if (myDisposableT != null)
                {
                    myDisposableT.Dispose();
                }
                myT = null;
            }
            this.Clear();
            this.TrimExcess();
            disposed = true;
        }
    }
    ...
}

用法：

using (MyDisposableList<System.Drawing.Bitmap> myList = new ...)
{
    // add bitmaps to the list (bitmaps are IDisposable)
    // use the elements in the list
}

using 语句的末尾自动处理 myList，从而处理 myList 中的所有位图
顺便说一句：如果您从文件加载位图并且忘记 Dispose() 该位图，您不知道何时可以删除该文件。

Answer 6

如果您确实要立即处置这些对象，您可以调用 GC.Collect() ，但根据我的理解，由 GC 决定是否收集内存。
这反过来将为每个应释放的对象调用 Finalize() 方法。
请注意，如果收集超出范围，GC 最终将收集图像使用的内存。
如果您使用实现 IDisposeable 的集合，则还可以使用 using 构造。这将保证当集合超出范围时（或几乎在范围结束后），对象将被准确处置。