return the variable used for using inside the using C#

Question

I am returning the variable I am creating in a using statement inside the using statement (sounds funny):

public DataTable foo ()
{
    using (DataTable properties = new DataTable())
    {
       // do something
       return properties;
    }
}

Will this Dispose the properties variable??

After doing this am still getting this Warning:

Warning 34 CA2000 : Microsoft.Reliability : In method 'test.test', call System.IDisposable.Dispose on object 'properties' before all references to it are out of scope.

Any Ideas?

Thanks

Regardless, this is just bad design and should be reworked.

Nick Larsen
– Nick Larsen

2010-05-12 20:56:27 +00:00
Commented May 12, 2010 at 20:56 — Nick Larsen
– Nick Larsen, Commented May 12, 2010 at 20:56

Robert Harvey · Accepted Answer · 2010-05-12 20:55:02Z

13

If you want to return it, you can't wrap it in a using statement, because once you leave the braces, it goes out of scope and gets disposed.

You will have to instantiate it like this:

public DataTable Foo() 
{ 
    DataTable properties = new DataTable();
    return properties; 
}

and call Dispose() on it later.

answered May 12, 2010 at 20:55

Robert Harvey

182k48 gold badges349 silver badges516 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Nick Larsen Over a year ago

It feels like foo() == GetUsefulDataTable() and the using block should be what calls this function.

Jon Skeet · Accepted Answer · 2010-05-12 20:56:58Z

12

Yes, it will dispose it - and then return it. This is almost always a bad thing to do.

In fact for DataTable, Dispose almost never does anything (the exception being if it's remoted somewhere, IIRC) but it's still a generally bad idea. Normally you should regard disposed objects as being unusable.

answered May 12, 2010 at 20:56

Jon Skeet

1.5m893 gold badges9.3k silver badges9.3k bronze badges

3 Comments

Jhonny D. Cano -Leftware- Over a year ago

So, what would be the correct pattern for returning a IDisposable object from a method without triggering CA2000 warning?

Jon Skeet Over a year ago

@Jhonny: I don't know, to be honest - I haven't used code analysis like this. I'd expect there'd be some way to suppress the warning.

IanNorton Over a year ago

@JhonnyD.Cano-Leftware- If you are going to instantiate and return IDisposable things you need to explicitly dispose them in your code. Your code analysis "should" pick up that you dispose this elsewhere manually.

Toby · Accepted Answer · 2010-05-12 21:08:36Z

7

Supposedly, this is the pattern for a factory method that creates a disposable object. But, I've still seen Code Analysis complain about this, too:

        Wrapper tempWrapper = null;
        Wrapper wrapper = null;

        try
        {
            tempWrapper = new Wrapper(callback);
            Initialize(tempWrapper);

            wrapper = tempWrapper;
            tempWrapper = null;
        }
        finally
        {
            if (tempWrapper != null)
                tempWrapper.Dispose();
        }

        return wrapper;

This should guarantee that if the initialization fails, the object is properly disposed, but if everything succeeds, an undisposed instance is returned from the method.

MSDN Article: CA2000: Dispose objects before losing scope.

edited May 12, 2010 at 21:08

answered May 12, 2010 at 21:02

Toby

7,6143 gold badges28 silver badges27 bronze badges

3 Comments

Juliet Over a year ago

Isn't this basically equivalent to a catch block? Why wouldn't you write Wrapper x = null; try { ... } catch { if (x != null) x.Dispose(); }. The intent is not only 100% more obvious, but avoids the unnecessary temp variable and manual cleanup.

Toby Over a year ago

I don't disagree. But I just looked this up recently myself, not because I was worried about disposing the object on failure, but because I was trying to find the code pattern that would eliminate the CA2000 warning without me having to suppress it via attribute. The code analysis process specifically checks to see if the object is disposed in a finally block due to the nature of the rule being enforced. I perceive that this question is really about CA2000, not about disposing objects.

supercat Over a year ago

@Juliet: The catch statement is missing a rethrow, and even with a rethrow the semantics aren't the same as not having a catch. Among other things, if the try block contains to calls to some method blah which could cause an exception, catch-and-rethrow will cause the stack trace to show the line number of the rethrow rather than the the call to blah (the stack trace within blah will be correct, but the line number for the call won't be).

Greg · Accepted Answer · 2010-05-12 20:56:38Z

3

Yes. Why are you using the using keyword on something you don't want disposed at the end of the code block?

The purpose of the using keyword is to dispose of the object.

http://msdn.microsoft.com/en-us/library/yh598w02.aspx

answered May 12, 2010 at 20:56

Greg

2,2391 gold badge16 silver badges20 bronze badges

Comments

unholysampler · Accepted Answer · 2010-12-10 16:43:48Z

2

The point of a using block is to create an artificial scope for a value/object. When the using block completes, the object is cleaned up because it is no longer needed. If you really want to return the object you are creating, than it is not a case where you want to use using.

This will work just fine.

public DataTable foo ()
{
    DataTable properties = new DataTable();
    // do something
    return properties;
}

edited Dec 10, 2010 at 16:43

answered May 12, 2010 at 20:59

unholysampler

17.4k7 gold badges51 silver badges65 bronze badges

Comments

Phil Lamb · Accepted Answer · 2010-05-12 20:59:44Z

1

Your code using the using keyword expands to:

{
    DataTable properties = new DataTable();
    try
    {
        //do something
        return properties;
    }
    finally
    {
        if(properties != null)
        {
            ((IDisposable)properties).Dispose();
        }
    }
}

Your variable is being disposed by nature of how using works. If you want to be able to return properties, don't wrap it in a using block.

answered May 12, 2010 at 20:59

Phil Lamb

1,43710 silver badges15 bronze badges

Comments

StriplingWarrior · Accepted Answer · 2010-05-12 21:35:41Z

0

The other responses are correct: as soon as you exit the using block, your object is disposed. The using block is great for making sure that an object gets disposed in a timely manner, so if you don't want to rely on the consumers of your function to remember to dispose the object later, you can try something like this:

public void UsingDataContext (Action<DataContext> action)
{
    using (DataContext ctx = new DataContext())
    {
       action(ctx)
    }
}

This way you can say something like:

var user = GetNewUserInfo();
UsingDataContext(c => c.UserSet.Add(user));

answered May 12, 2010 at 21:35

StriplingWarrior

158k29 gold badges261 silver badges326 bronze badges

Collectives™ on Stack Overflow

return the variable used for using inside the using C#

7 Answers 7

1 Comment

3 Comments

3 Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

1 Comment

3 Comments

3 Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related