Cast type to IDisposable - Why?

Question

Saw this. Why the explicit cast to IDisposable? Is this just a shorthand to ensure that IDisposable is called on exiting the using block?

using (proxy as IDisposable)
{
  string s = proxy.Stuff()                                    
}

Answer 1

This "trick", if you can call it that, is most likely due to proxy being of a type that the compiler can't verify really implements IDisposable.

The nice thing about the using directive, is that if the parameter to it is null, then no call to Dispose will be done upon exiting the scope of the using statement.

So the code you've shown is actually short-hand for:

var disposable = proxy as IDisposable;
try
{
    string s = proxy.Stuff();
}
finally
{
    if (disposable != null)
        disposable.Dispose();
}

In other words, it says "if this object implements IDisposable, I need to dispose of it when I'm done with the following piece of code."

Answer 2

This could be required if you are given a proxy instance from somewhere and its static type does not implement IDisposable but you know that the real type may do and you want to make sure it will be disposed e.g.

public class Proxy : ISomeInterface, IDisposable
{
    ...
}

private ISomeInterface Create() { ... }

ISomeInterface proxy = Create();

//won't compile without `as`
using(proxy as IDisposable)
{
    ...
}