views:

321

answers:

1

... if I use an IDisposable in a local variable, but do not call Dispose() or use the using() pattern.

public void BadMethod()
{
    var fs = new FileStream("file.txt", FileMode.Create);
    fs.WriteByte(0x55);
    // no dispose, no using()
}

Just like the "Types that own disposable fields should be disposable" rule for fields.


EDIT: Replaced MemoryStream by FileStream, because MemoryStream just allocates memory and doesn't use (unmanaged) resources, so someone could discuss about a mandatory Dispose() call.

+8  A: 

Is there an FxCop rule for this? Yes and no.

In FxCop 1.35, which is what Visual Studio 2005 Code Analysis is based on, there was a rule DisposeObjectsBeforeLosingScope which did exactly this.

In FxCop 1.36 (Visual Studio 2008 Code Analysis), they removed their data flow analysis engine, which meant that this rule also had to be removed.

However, in the next FxCop (Visual Studio 2010 Code Analysis), it seems that DisposeObjectsBeforeLosingScope has returned!

bobbymcr
+1. Didn't know it's added to 2010. While I don't necessarily agree with the rule, this is a direct answer to the question.
Mehrdad Afshari
BTW: On your second link: What does "Returning a disposable object requires that the object is constructed in a try/finally block outside of a using block" mean??
ulrichb
They actually cover this in the sample in that article. Look at the `OpenPort2` method. Basically, if the object is constructed but fails to initialize, it should be `Dispose()`'d before throwing the exception to the user (otherwise it goes out of scope). A `using` would not be appropriate here because the *caller* is expected to call `Dispose()` at a later time.
bobbymcr
OK. Agree. But couldn't I do the same by using `try-catch` and re-throwing the exception after disposing the serial port? This way I would not need the `tempPort` variable.
ulrichb
Yeah, that would probably be about the same. But I think the reason they do it this way is more about convention and consistency. Most people expect to see resource cleanup in a finally block, and it also avoids duplication in case there are multiple catch handlers. There are also subtle differences in how a debugger behaves for catching/rethrowing vs. not catching (see http://blogs.msdn.com/jmstall/archive/2007/02/07/catch-rethrow.aspx ).
bobbymcr