4

我已经在 SO 中查看过类似这样的问题，即使我发现了很多，但其中任何一个都为我提供了关于这个问题的任何信息。

假设我有这个代码：

public class SuperObject : IDisposable
{
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing) { }
}
  • 我需要protected virtual void Dispose(bool)开SuperObject吗？因为那里真的没有什么可处置的。
public interface ICustom : IDisposable { }

public class Custom : ICustom
{
    public SuperObject Super { get; protected set; }

    public Custom()
    {
        Super = new SuperObject();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public virtual void Dispose(bool disposing)
    {
        if (!disposing) return;

        if (Super != null)
            Super.Dispose();
    }
}

public class Foo
{
    public Foo()
    {
        using (var c = new Custom())
        {
            //do magic with c
        }
    }
}

现在，如果我想要/需要/尝试在已经实现并已经实现 IDisposableCustom的类上使用会发生什么？System.Web.Mvc.Controller

public class Moo : Controller
{
    Custom c;

    public Moo()
    {
        c = new Custom();
    }

    // Use c throughout this class        
}

如何正确c处置Moo？

4

2 回答 2

9

正常的方法是应用标准的 IDisposable 实现- 但是，这只有在您的类或派生自它的某些类将使用非托管资源时才真正需要 -这种情况实际上非常罕见（并且当这种情况确实适用时，最好包装具有完整标准 IDisposable 实现的自己的类中的非托管资源）。

因此，假设您不处理非托管资源（原始文件句柄、全局分配的内存等）并且只处理一次性成员（即具有托管资源并实现 IDisposable），那么您可以安全地获得一种最小化的方法IDispose - 即：

只需一个 void Dispose() 方法。在该方法中，只需在可处置成员上调用 dispose，然后在基类上调用 Dispose（如果它是可处置的）。如果您有一个类层次结构，则可以将此 Dispose 虚拟化。不需要 Dispose(bool) 方法。也不需要检查对象是否已被释放——因为您所做的只是在其他对象上调用 dipsose，而这些实现将进行检查。

如果您不喜欢最小化方法，请应用标准的完整实现（但这不是绝对必要的）。即要么做一个标准的实施，因为你坚持遵循推荐的方法，要么做一个简单的最小（但正确）的实施——但不要在两者之间做任何事情（即不标准，不简单或不正确）！

有关更多详细信息，请参阅此问题：Minimal IDispose implimation for managed resources only

因此，在您的情况下，以下是最小的暗示：

public class SuperObject : IDisposable {
    public void Dispose() {
        // Dispose code...just call dispose on dispoable members.
        // If there are none then no need to implement IDisposable!
    }
}

public interface ICustom : IDisposable { }
public class Custom : ICustom {
    public SuperObject Super { get; protected set; }

    public Custom() {
        Super = new SuperObject();
    }

    public void Dispose() {
        if (Super != null)
            Super.Dispose();
    }
}  

public class Moo : Controller {
    Custom c;

    public Moo() {
        c = new Custom();
    }

    public Dispose() {
        if (c!=null)
            c.Dispose()
        base.Dispose();       
    }
}

请注意，如果 Super 对象没有任何一次性资源，那么实现 IDisposable 并拥有 Dispose 方法是没有意义的。如果海关唯一的一次性对象是 SuperObject，那么同样适用，同样的逻辑也适用于 Moo。最后，如果上述所有条件都适用并且周围没有其他一次性物品，那么您真正需要的是：

  public class Moo : Controller {
        Custom c;
    
        public Moo() {
            c = new Custom();
        }
    
        public Dispose() {
           base.Dispose();       
        }
    }
于 2013-09-29T09:56:14.537 回答
3

如何正确c处置Moo？

public class Moo : Controller
{
    Custom c;

    public Moo()
    {
        c = new Custom();
    }

    // Use c throughout this class    


    protected override Dispose(bool disposing)
    {
        base.Dispose(disposing);
        if (disposing)
           c.Dispose()
    }
}

这也回答了你的第一个问题，Controller需要制作它的Dispose(bool)方法protected virtual，否则上面的方法是不可能的。

但有几点注意事项：

  • 你没有任何isDisposed逻辑。只进行一次处理是个好主意，您可能希望在处理后捕获使用情况。
  • 省略析构函数（终结器）本身是一个好主意，但您现在有了额外的约束，即派生类不应拥有非托管资源。
于 2013-09-29T09:21:09.127 回答