C# Using Statement and iDisposable

IDisposable is implemented for example by objects that give access to unmanaged or expensive resources, like files, database connections and things like that. So to a certain extent, you can guess. For the rest, intellisense tells you if the Dispose() method is available on the object.

how can you easily tell which objects implement iDisposable?

Programatically one can use.

IDisposable disposable = obj as IDisposable; if(disposable!=null) { //this object implements IDisposable } else { //Not implement IDisposable interface } 

If it's a standard class, then the MSDN documentation page should say if it implements IDisposable or not. Third-party libraries also usually come with documentation. Otherwise, if you're using an IDE like Visual Studio, you can inspect the class (F12 key) and see what interfaces it implements.

If you right click and choose Goto Declaration you should get the object browser there you can se all interfaces implemented by the class.

Otherwise use the intellisense to check if the class has a Dispose() -method, in which case you use Using.

And lastly, if you try to use Using on something thats Not an IDisposable you´ll get a compiler error.

Using the Object Explorer you should be able to traverse the hierarchy to see the root of the object you're trying to use.

The compiler will warn you, though, if the variable that you're trying to use is not IDisposable:

using (int i = 1) { // ... } 

will give you an error:

Error 1 'int': type used in a using statement must be implicitly convertible to 'System.IDisposable'

You can check this way also

if (anyobject is IDisposable) { //it implemants IDisposable } 

If one can employ a "Using" statement and have it work, one generally should. One type of situation to watch out for is creating an object and passing it as a property of some other object. There are four approaches the framework can take here:

1. A snapshot is taken of the passed-in IDisposable. The receiving object will take care of disposing the snapshot; the supplier of the IDisposable is responsible for Disposing it, and it may do so at any time after the snapshot is taken.
2. A snapshot is taken of the passed-in IDisposable, without care of whether it's been disposed or not. The supplier is responsible for Disposing the IDisposable, but could legitimately do so at any time--even before it's passed in. The "Font" properties of controls seem to behave this way. If a Font object is going to be used only to set controls' Font properties, one could Dispose the font as soon as it's created and not have to worry about cleaning it up later.
3. The receiving object requires that the passed-in object not be Disposed until the receiving object is done with it, whereupon the receiving object will Dispose it.
4. The receiving object requires that the passed-in object not be Disposed until the receiving object is done with it, but the sending object is still responsible for Disposing it.

Unfortunately, Microsoft seems to use different approaches to IDisposable objects in different parts of the framework. Sometimes the best thing to do is dispose of the object immediately after setting the property, and see if that causes problems when the receiving object tries to use it.