dispose

I wanted to know if there are any conventions regarding disposal of disposable items nested inside another disposable item(in a property/public field, not as private members). For example, a DataSet contains DataTable(s) and a SqlCommand contains a SqlConnection. The obvious thing would be for a class to dispose of all Disposable items it owns, and leave the rest. Does there exist such a convention? If it does, how does .NET libraries determine who owns what? How can I find out whether nested objects are being disposed? PS: I have been wondering about this for a while, and apparently so have

I am creating an object(obj below) in using and return that object as part of the function return.Will this cause any problem like object will be disposed before I try to use returned value in another function ? using (MyObject obj = new MyObject()) { . . . return obj; } Will this cause any problem like object will be disposed before I try to use returned value in another function? Yes. Can you explain what you're trying to do here? This code doesn't make any sense. The whole point of "using" is that you are using the object here only and then automatically getting rid of its scarce unmanaged

In a VB.NET program I'm creating a new bitmap image, I then call Graphics.FromImage to get a Graphics object to draw on the bitmap. The image is then displayed to the user. All the code samples I've seen always call .Dispose() on Bitmaps and Graphics objects, but is there any need to do that when neither have touched files on disk? Are there any other unmanaged resources that these objects might have grabbed that wouldn't be cleared by the garbage collector? Yes. Always call Dispose() on any object that implements IDisposable . GDI handles used by graphics objects are unmanaged and require

I understand that it is used to deallocate unmanaged resources, however, I am confused as to when Dispose is actually called. I know it is called at the end of a using block, but does it also get invoked when the object is garbage collected? If you implement IDisposable correctly, you should also include a finalizer that will call Dispose() on your object. If you do that, it will get called by the GC. However, it's still a VERY good idea to try to always dispose of these objects yourself. The biggest problem with relying on the finalizer to call Dispose is that it will happen in another thread

Assuming this as the traditional Dispose pattern (taken from devx but seen on many websites) class Test : IDisposable { private bool isDisposed = false; ~Test() { Dispose(false); } protected void Dispose(bool disposing) { if (disposing) { // Code to dispose the managed resources of the class } // Code to dispose the un-managed resources of the class isDisposed = true; } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } } I don't understand why we call GC.SupressFinalize(this) . This requires me to write my own managed resource disposal, including nulling my references? I'm a