Will Dispose() be called in a using statement with a null object?

Question

Is it safe to use the using statement on a (potentially) null object?
Consider the following example:

class Test {
 IDisposable GetObject(string name) {
 // returns null if not found
 }
 void DoSomething() {
 using (IDisposable x = GetObject("invalid name")) {
 if (x != null) {
 // etc...
 }
 }
 }
}

Is it guaranteed that Dispose will be called only if the object is not null, and I will not get a NullReferenceException?

• Brian Rasmussen: Related stackoverflow.com/questions/2513035
• Eric Mutta: To answer your last question directly from the language spec: If a null resource is acquired, then no call to Dispose is made, and no exception is thrown.

Answer 1

Yes, Dispose() is only called on non-null objects:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/using

• surfen: Note that even if your variable is null, the using block is executed, and if you reference your variable inside the using block without first null-checking it, you WILL get NullReferenceException. To prevent misinterpretation, this answer should state: "Yes, Dispose() is only called on non-null objects".
• Christopher Hamkins: The page referenced by the link doesn't mention (anymore?) what happens when the object is null.
• h.m.i.13: This page proves the answer: learn.microsoft.com/en-us/dotnet/csharp/language-reference/…

Answer 2

The expansion for using checks that the object is not null before calling Dispose on it, so yes, it's safe.

In your case you would get something like:

IDisposable x = GetObject("invalid name");
try
{
 // etc...
}
finally
{
 if(x != null)
 {
 x.Dispose();
 }
}

Answer 3

You should be ok with it:

using ((IDisposable)null) { }

No exception thrown here.

Side note: don't mistake this with foreach and IEnumerable where an exception will be thrown.

Answer 4

Yes, before Disposing the reference will be null-checked. You can examine yourself by viewing your code in Reflector.

Answer 5

I came across this question as I had an object where I don't know whether it requires and supports disposing. The way I dealt with this is to cast it to IDisposable using the as keyword. Here's an example:

void DoSomethingWithMyType(Func<IMyType> factory)
{
 IMyType myObj = factory();
 // Some but not all implementations IMyType of implement IDisposable
 using (myObj as IDisposable)
 {
 myObject.DoSomething();
 }
}

In my example scenario IMyType is an interface that doesn't implement IDisposable itself, but some classes that implement IMyType are known to implement IDisposable while others do not. In the former case, the myObj as IDisposable expression produces an IDisposable object on which on implicit call to Dispose is made leaving the using block. In the latter case, the expression produces null, in which case nothing happens, and crucially, no exception is raised when leaving the using block.

Answer 6

You will not get null reference exception as per my experience. It will be simply ignored.