Returning a Disposable Object from a Method

Question

4.00/5 (1 vote)

See more:

On the MSDN site in the topic about code analysis warning CA2000, a general pattern is recommended for a method which returns a disposable object. Can anyone explain why this pattern needs the temporary variable and why it uses a 'finally' clause rather than a 'catch' clause for code which is only relevant when an exception occurs? In other words, is there any reason why the MSDN recommmendation would be preferable to the second code sample below?

MSDN Recommendation

public SerialPort OpenPort2(string portName)
{
   SerialPort tempPort = null;
   SerialPort port = null;
   try
   {
      tempPort = new SerialPort(portName);
      tempPort.Open();
      SomeMethod();
      //Add any other methods above this line
      port = tempPort;
      tempPort = null;

   }
   finally
   {
      if (tempPort != null)
      {
         tempPort.Close();
      }
   }
   return port;
}

Why Not This Simplification?

public SerialPort OpenPort2(string portName)
{
    SerialPort port = null;
    try
    {
        port = new SerialPort(portName);
        port.Open();
        SomeMethod();
        //Add any other methods above this line
    }
    catch
    {
        if (port != null)
        {
            port.Close();
        }
        throw;
    }
    return port;
}

Posted 15-May-12 5:13am

Robert Ranck

Updated 15-May-12 5:42am

v2

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

VJ Reddy · Answer 1 · 2012-05-15T05:41:00

The reason is that the catch block gets executed only if an exception is thrown, whereas the finally block gets executed both in case of normal execution without an exception and in case an exception occurs.

So, in the second example the port.Close gets executed only when an exception occurs and remains open in the normal execution. As per MSDN documentation for an object implementing the IDisposable interface the Dispose method is to be called in the finally block.

The disposable pattern is implemented with IDisposable interface to ensure that the resources held by an object are released properly.

The try finally block is implicitly implemented by the using block and it is convenient to use using block with an object implementing IDisposable interface as explained here http://msdn.microsoft.com/en-us/library/yh598w02.aspx[^]

woopsydoozy · Answer 2 · 2012-05-15T05:37:00

Solution 1

I'd guess it depends on the disposable object. In your simplification, you attempt to open a port, allow any error to occur, attempt to close the port, and then return that same port. So if the port object holds any state information about what's been done to it, you've got whatever mess was created by your attempted initialization instead of a clean, null copy, as in the MSDN example.

Posted 15-May-12 5:37am

woopsydoozy

Comments

Robert Ranck 15-May-12 11:45am

I made an error when entering the simplification, which is now corrected. There is now a 'throw' in the catch clause. So in either set of code, an error should result in the object being disposed if it was created and an exception being thrown.

woopsydoozy 15-May-12 11:55am

Agreed, now they're basically the same. One caution: I don't think you should count on a Close counting as a Dispose--again, depends on the object.

Robert Ranck 15-May-12 12:08pm

According to Microsoft's guidelines for .NET Framework classes, when a class implements both a Dispose() method and a Close() method, they should be functionally equivalent. In this particular case, I didn't do any research to verify that for the SerialPort class because I assumed that whoever wrote the MSDN code sample had already done so. Normally I would verify that Close() does a Dispose(), or just use a Close() followed by a Dispose() if the documentation was unclear.