Why is using(null) a valid case in C#?

Question

Could someone please explain to me why the code shown below is valid in C# and executes the call to Console.WriteLine?

using (null) 
{
   Console.WriteLine ("something is here")
}

It compiles into (finally block is shown). As you can see compiler decides not to execute the Dispose() method and jumps to the endfinally instruction.

IL_0013:  ldnull
IL_0014:  ceq
IL_0016:  stloc.1
IL_0017:  ldloc.1
IL_0018:  brtrue.s   IL_0021 // branches here and decide not to execute Dispose()
IL_001a:  ldnull
IL_001b:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
IL_0020:  nop
IL_0021:  endfinally

However, if I run the following code, it will fail with a NullReferenceException (which is expected):

((IDisposable)null).Dispose();
IL_0023:  ldnull
IL_0024:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()

Why does the first version compile? Why does the compiler decide not to execute Dispose()? Are there any other cases when compiler may decide not to call Dispose() in a using block?

hmmm... I'm now very dubious of this post, given Eric's recent blog... is this really a genuine question? — Marc Gravell, Mar 04 '11 at 08:44
Isn't this already asked? http://stackoverflow.com/questions/2522822/c-using-statement-with-a-null-object — Vladislav Rastrusny, Mar 04 '11 at 08:49

Marc Gravell · Answer 1 · 2011-03-04T08:48:26.147

17

The language spec explicitly states (8.13) that the captured value is tested for null if necessary, i.e. the finally is essentially (with caveats around non-nullable types)

if(tmp != null) tmp.Dispose();

I frequently use this to my advantage, for things that might be null, but when they aren't: need disposing. In fact, here's a useful scenario (manually enumerating IEnumerable):

IEnumerable blah = ...; // note non-generic version
IEnumerator iter = blah.GetEnumerator();
using(iter as IDisposable)
{
    // loop
}

as the non-generic version of IEnumerator isn't necessarily IDisposable, but when it is, should be disposed.

edited Mar 04 '11 at 08:48

answered Mar 04 '11 at 08:42

Marc Gravell

1,026,079
266
2,566
2,900

1

Thanks for nice trick with *as IDisposable*. Exactly what I was looking for. – Andrey Taptunov Mar 04 '11 at 08:45
This is too clever for my taste :) – mafu Apr 05 '12 at 15:48

score 1 · Answer 2 · edited May 23 '17 at 12:17

1

I think it's a natural outcome of the more general case of using(some_expression), where some_expression is allowed to evaluate to null.

It would have required a special rule to distinguish this case from the more general one.

edited May 23 '17 at 12:17

Community

1
1

answered Mar 04 '11 at 08:43

sbi

219,715
46
258
445

score 0 · Answer 3 · answered Mar 04 '11 at 08:44

0

It will ignore if the Object is null - http://msdn.microsoft.com/en-us/library/yh598w02.aspx

answered Mar 04 '11 at 08:44

Anuraj

18,859
7
53
79

Where does it say that in the documentation you linked to? A search for `null` on that page returned 0 hits. – Cody Gray - on strike Mar 04 '11 at 08:46
1

In the remarks section. if (font1 != null) ((IDisposable)font1).Dispose(); – Anuraj Mar 04 '11 at 08:48
> A using statement is translated into three parts: acquisition, usage, and disposal. Usage of the resource is implicitly enclosed in a try statement that includes a finally clause. This finally clause disposes of the resource. If a null resource is acquired, then no call to Dispose is made, and no exception is thrown. https://msdn.microsoft.com/en-us/library/aa664736(v=vs.71).aspx – boro Dec 01 '15 at 14:40

Why is using(null) a valid case in C#?

3 Answers3