dispose

Recently, I was researching some tricky bugs about object not disposed. I found some pattern in code. It is reported that some m_foo is not disposed, while it seems all instances of SomeClass has been disposed. public class SomeClass: IDisposable { void Dispose() { if (m_foo != null) { m_foo.Dispose(); } if (m_bar != null) { m_bar.Dispose(); } } private Foo m_foo; private Bar m_bar; } I suspects that Foo.Dispose might throw a exception, so that following code is not executed so m_bar is not disposed. Since Foo/Bar might be from third party, so it is not guaranteed to not throwing exception. If

I am using C#. Is it advised to unit test dispose methods? If so why, and how should one test these methods? Yes, but it might be hard. There are two things that can generally happen in Dispose implementation: Unmanaged resources are released. In this case it's pretty hard to verify that the code called, for example, Marshal.Release . A possible solution is to inject an object that can do the disposing and pass a mock to it during testing. Something to this effect: interface ComObjectReleaser { public virtual Release (IntPtr obj) { Marshal.Release(obj); } } class ClassWithComObject :

I am attempting to expose an IQueryable<> over ASP.NET Web API and I find that I need to keep the data source open until the request completes, so that the OData query system built into ASP.NET Web API can do its job. OK, that sounds perfectly reasonable. But where do I dispose of the data source? I do not see any obvious place for this. Should I manage request state in the Application? What is the standard way to do this? Is the Dispose() method of the controller the appropriate place? I.e. is there a guarantee that one controller instance serves only one request or is that just an

Say I want to define a TempFileStream class that creates a temporary file using Path.GetTempFileName() method. A temporary file must be deleted when TempFileStream's object is no longer needed, e.g. closed or disposed: class TempFileStream: FileStream { string m_TempFileName = Path.GetTempFileName(); public TempFileStream(FileMode fileMode): base(m_TempFileName,fileMode) {} /// ... public ovverride Dispose(bool disposing) { /// ??? } } How should I implement this simply and safely? Try this one instead: public class TempFileStream : FileStream { public TempFileStream() : base(Path

Let's say I have a class that implements the IDisposable interface. Something like this: MyClass uses some unmanaged resources, hence the Dispose() method from IDisposable releases those resources. MyClass should be used like this: using ( MyClass myClass = new MyClass() ) { myClass.DoSomething(); } Now, I want to implement a method that calls DoSomething() asynchronously. I add a new method to MyClass : Now, from the client side, MyClass should be used like this: using ( MyClass myClass = new MyClass() ) { myClass.AsyncDoSomething(); } However, if I don't do anything else, this could fail as

I've got a class named BackgroundWorker that has a thread constantly running. To turn this thread off, an instance variable named stop to needs to be true . To make sure the thread is freed when the class is done being used, I've added IDisposable and a finalizer that invokes Dispose() . Assuming that stop = true does indeed cause this thread to exit, is this sippet correct? It's fine to invoke Dispose from a finalizer, right? Finalizers should always call Dispose if the object inherits IDisposable , right? /// <summary> /// Force the background thread to exit. /// </summary> public void