using with object type

Question

I try to write the following code and get an error

using (object obj = await command.ExecuteScalarAsync())
{
   //....
}

Implicitly convertible to System.IDisposable

How to solve that? I tried the cast (the static one doesn't work...)
If I don't use using and check that the object is not null I do the casting in the following way:

Convert.ToInt32(obj);

But I should use using

accoding to the definition of the method it returns object.But actually it runs stored procedure and return SCOPE_IDENTITY(),which can be DBNull.value — YAKOVM, Jan 15 '14 at 12:39

score 4 · Accepted Answer · answered Jan 15 '14 at 12:38

4

You don't need to dispose in this case, simply do:

object obj = await command.ExecuteScalarAsync();

ExecuteScalarAsync returns a Task<T>, which you are subsequently awaiting. This "awaiting" will handle the task object, you get the result from the task/execution, which is very unlikely to require disposal.

answered Jan 15 '14 at 12:38

Lasse V. Karlsen

380,855
102
628
825

1

can you explain why is it very unlikely to require disposal? – YAKOVM Jan 15 '14 at 12:42
@Yakov Well, it returns a value from the DB. The only way it *could* require disposing is if it returned a .NET object, that for some reason implemented `IDisposable`. In that case, you would simply cast the return value to `IDisposable`, and using would work just fine. – Luaan Jan 15 '14 at 12:46
This Answer provides the reason why you dont need to dispose it http://stackoverflow.com/a/3734298/394381 – Ali Khalid Jan 15 '14 at 12:46
`ExecuteScalar` it will return an int, string, etc. from the database. It would help to give a definite answer to know the SQL you execute there, but I think it is highly unlikely that any objects you get back from a *scalar* query requires any form of cleanup. – Lasse V. Karlsen Jan 15 '14 at 12:46

score 3 · Answer 2 · answered Jan 15 '14 at 12:39

3

Using statement is only valid (and useful) with IDisposable objects. It gives you nothing if your object is not disposable. Basically, it's syntactic sugar for this equivalent code:

IDisposable obj = ...;
try
{
  ...
}
finally
{
  obj.Dispose();
}

The guys implementing the C# compiler simply decided that having the using statement available for classes that don't implement IDisposable would be useless and confusing.

It doesn't work in any way as with or some other statement that looks superficially similar. It will not affect garbage collection in any way (apart from perhaps limiting variable scope - but simple blocks ({ ... }) to the very same thing.

Safely getting the value is something completely different. You want to do something like this:

object val = await command.ExecuteScalarAsync();

if (val == DBNull.Value)
{
  // It's null
}
else
{
  int realValue = (int)val;
}

answered Jan 15 '14 at 12:39

Luaan

62,244
7
97
116

3

It's not just only useful with `IDisposable` but it is required to be `IDisposable`. – Tim Schmelter Jan 15 '14 at 12:40
1

@TimSchmelter: Yes, I know. I was talking about the motivation behind the statement - it wouldn't do anything for a class that doesn't implement `IDisposable`, so why should the compiler allow it? – Luaan Jan 15 '14 at 12:41
1

Your answer would be more accurate if you'd add this. – Tim Schmelter Jan 15 '14 at 12:42
@TimSchmelter: Better? – Luaan Jan 15 '14 at 12:44

score 2 · Answer 3 · answered Jan 15 '14 at 13:00

I agree with everyone that using is only useful with IDisposable and I can't think of a single reason that I would need to dispose of the scalar returned by ExucuteScaler. That said if you ever run into a method that does return a mix of disposable and non disposable values you can do this:

static void Main(string[] args)
{
    object obj1 = Foo();

    using (IDisposable disp = obj1 as IDisposable)
    {
        // operate on obj1 only since disp might be null
    }
}

using will just ignore a null value so if ojb1 doesn't support IDisposable the as will cast to null and everything works. If it does then the object is disposed.

I have never needed this bit of trivia because any method that returns a mix of IDisposable and non diposable objects is a bad design but it could happen someday. :-)

using with object type

3 Answers3