标签: idisposable

如果我有一个SomeDisposableObject实现的类IDisposable:

class SomeDisposableObject : IDisposable
{
    public void Dispose()
    {
        // Do some important disposal work.
    }
}

我有另一个叫做的类AContainer,它有SomeDisposableObject一个公共属性的实例:

class AContainer
{
    SomeDisposableObject m_someObject = new SomeDisposableObject();

    public SomeDisposableObject SomeObject
    {
        get { return m_someObject; }
        set { m_someObject = value; }
    }
}

然后FxCop将坚持AContainer也是IDisposable.

这是很好的,但我看不出我可以安全地调用m_someObject.Dispose()从AContainer.Dispose(),作为另一个类可能还是要在一个参考m_someObject实例.

避免这种情况的最佳方法是什么？

(假设其他代码依赖于AContainer.SomeObject始终具有非空值,因此只是将实例的创建移到外部AContainer不是一个选项)

编辑:我将扩展一些例子,因为我认为一些评论者错过了这个问题.如果我只实现一个调用m_someObject.Dispose()的Dispose()方法,AContainer那么我将留下这些情况:

// Example One
AContainer …

这个类使用a StreamWriter并因此实现IDisposable.

public class Foo : IDisposable
{
    private StreamWriter _Writer;

    public Foo (String path)
    {
        // here happens something along the lines of:
        FileStream fileWrite = File.Open (path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
        _Writer = new StreamWriter (fileWrite, new ASCIIEncoding ());
    }

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

    ~Foo()
    {
        Dispose (false);
    }

    protected virtual void Dispose (bool disposing)
    {
        if (_Disposed) {
            return;
        }
        if (disposing) {
            _Writer.Dispose ();
        }
        _Writer = null; …

我无法相信我仍然对此感到困惑但是,无论如何,让我们最终指出:

我有一个类覆盖OnPaint来做一些绘图.为了加快速度,我在构造函数中预先创建了笔,画笔等,以便OnPaint不需要继续创建和处理它们.

现在,我确保我总是处理这些对象,但我感觉我不需要,因为尽管它们实现了IDisposable,但它们都是托管对象.

它是否正确？

感谢所有的答案,这个问题肯定已被钉上了.
我很高兴我一直保持警惕,总是使用'​​使用',所以我不需要经历所有的代码检查.我只想清楚我不是一个毫无意义的用户.

顺便说一句,我确实有一个奇怪的情况,最近,我不得不更换一个使用块并手动调用dispose!我会把它挖出来并创造一个新问题.

我知道C#可以通过垃圾收集器很好地管理资源.但既然它有,那究竟是什么,为什么需要呢？

任何人都可以解释为什么.Dispose()在asp.net mvc中需要？

另外,处理连接意味着什么？为什么需要？任何人都知道为什么处理数据库连接很重要的复杂性db.Dispose()？这与EF相关,还是与SQL Server相关？我想知道为什么.

protected override void Dispose(bool disposing)
{
   db.Dispose();
   base.Dispose(disposing);
}

我有几种处理DB的方法,所有这些方法都是从调用开始的

FaierDbDataContext db = new FaierDbDataContext();

由于Linq2Sql DataContext对象实现了IDisposable,它是否应该与"using"一起使用？

using (FaierDbDataContext db = new FaierDbDataContext()) {
    // use db here
}

以这种或那种方式使用它有什么含义？

我正在阅读有关如何实现IDisposable的MSDN文章,我不确定文章中引用的托管和本机资源之间的区别.

我有一个类在处理时必须处理它的两个字段.我应该将它们视为托管(仅在处置= true时处置)或本机资源吗？

我有一个父和子类都需要实现IDisposable.应该把virtual(和base.Dispose()？)电话放在哪里？当我只是覆盖Dispose(bool disposing)调用时,我觉得很奇怪,我IDisposable没有显式Dispose()函数(仅使用继承的函数)实现,但是还有其他所有功能.

我一直在做什么(微不足道):

internal class FooBase : IDisposable
{
    Socket baseSocket;

    private void SendNormalShutdown() { }

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

    private bool _disposed = false;
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                SendNormalShutdown();
            }
            baseSocket.Close();
        }
    }

    ~FooBase()
    {
        Dispose(false);
    }
}

internal class Foo : FooBase, IDisposable
{
    Socket extraSocket;

    private bool _disposed = false;
    protected override void Dispose(bool …

有时我需要在函数中使用几个一次性对象.最常见的情况是使用StreamReader和StreamWriter,但有时它甚至比这更多.

嵌套使用语句快速加起来并且看起来很难看.为了解决这个问题,我创建了一个小类,它收集IDisposable对象并在它本身被处置时处理它们.

public class MultiDispose : HashSet<IDisposable>, IDisposable
{
    public MultiDispose(params IDisposable[] objectsToDispose)
    {
        foreach (IDisposable d in objectsToDispose)
        {
            this.Add(d);
        }
    }

    public T Add<T>(T obj) where T : IDisposable
    {
        base.Add(obj);
        return obj;
    }

    public void DisposeObject(IDisposable obj)
    {
        obj.Dispose();
        base.Remove(obj);
    }


    #region IDisposable Members

    public void Dispose()
    {
        foreach (IDisposable d in this)
        {
            d.Dispose();
        }

    }

    #endregion
}

所以我的代码现在看起来像这样:

        using (MultiDispose md = new MultiDispose())
        {
            StreamReader rdr = md.Add(new StreamReader(args[0]));
            StreamWriter wrt = md.Add(new StreamWriter(args[1])); …

我很惊讶地发现Ninject创建的至少一个对象在请求结束时没有被处理掉,当它被定义为InRequestScope时

这是我试图处理的对象:

接口:

public interface IDataContext : IDisposable
{
    MessengerEntities context { get; set; }
}

MessengerEntities是Entity Framework的ObjectContext实现 - 我的上下文对象.

然后我创建一个具体的类,如下所示:

public class DataContext : IDataContext
{
    private MessengerEntities _context = new MessengerEntities();
    public MessengerEntities context
    {
        get
        {
            return _context;
        }
        set
        {
            _context = value;
        }
    }
    #region IDisposable Members

    public void Dispose()
    {
        context.Dispose();
    }

    #endregion
}

然后我有一个像这样的Ninject控制器工厂(这是以史蒂夫桑德森MVC 2书为蓝本):

public class NinjectControllerFactory : DefaultControllerFactory
{
    // a Ninject "kernel" is the thing that can supply object instances …

当你使用a ThreadLocal<T>和T实现IDisposable时,你应该如何处理ThreadLocal中的成员？

根据ILSpy,ThreadLocal的Dispose()和Dispose(bool)方法是

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

protected virtual void Dispose(bool disposing)
{
    int currentInstanceIndex = this.m_currentInstanceIndex;
    if (currentInstanceIndex > -1 && Interlocked.CompareExchange(ref this.m_currentInstanceIndex, -1, currentInstanceIndex) == currentInstanceIndex)
    {
        ThreadLocal<T>.s_availableIndices.Push(currentInstanceIndex);
    }
    this.m_holder = null;
}

ThreadLocal似乎没有尝试在其子成员上调用Dispose.我不知道如何引用它内部分配的每个线程,所以我可以处理它.

我使用以下代码运行测试,该类从未处理过

static class Sandbox
{
    static void Main()
    {

        ThreadLocal<TestClass> test = new ThreadLocal<TestClass>();
        test.Value = new TestClass();

        test.Dispose();
        Console.Read();
    }
}

class TestClass : IDisposable
{
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    protected void Dispose(bool Disposing)
    {
        Console.Write("I …