As a matter of coding style though, I still say using “as” here is putting a square peg in a round hole.

if(o is Something) {
((Something)o).Blah();
}

If I intend to do multiple operations after a cast, it’s nice to use ‘as’:

Something something = o as Something;
if(o != null) {
o.Blah();
o.Hooray();
}

It’s really useful when you are working with an object that implements many interfaces and you want to know if it’s ok to call a method from some interface. The ‘is’ will let you know if your cast is safe, or the ‘as’ will do the checking and the cast if it’s safe.

Unless you’re sure ‘as’ will not return null, or if it does and you do a check for null, be extremely careful with NullReferenceException (NRE). You basically _never_ want to have an NRE raised on you - ever.

Under the hood, an NRE is just a sign that the JIT tried to dereference a native null pointer, which in turn causes a SIGSEGV (segfault). The runtime however traps the SIGSEGV signal so it can translate it into the NRE and send it upstream to your managed application as an exception.

All this meaning that NREs are expensive and also can be prone to break your application if Mono mingles with some buggy library. If some library in your application traps SIGSEGV and doesn’t restore the previous signal handler, Mono will never be able to translate that SIGSEGV into an NRE and your application will crash for no apparent reason, and with no easy way to trace and find out why.

This was a big bug in GStreamer a few versions back where it trapped SIGSEGV during its plugin loading process but restored it to the system default handler and not the previous handler (Mono’s JIT), thus Mono became unable to recover from the SIGSEGV.

/me ends rant

Yes, I’m not saying that you should not use “as.” I’m saying you shouldn’t do it when doing a one-shot cast like “(o as Foo).DoSomething()” because if o can’t be converted to Foo the exception you get (NullReferenceException) will be very misleading.

Besides that.. my if scenario results in worse performance because the runtime now checks ‘o’ twice while with the ‘as’ keyword this is only done once.

Actually that test will catch it, because the “is” operator always returns false when the left operand is null. “o is MyObject” is asking the question “is o not null and can it be converted to MyObject?”

Note that null is special in this case because while “is” will always return false, a cast to anything (except for a value type) will succeed.

The same as retrieving objects from an untyped dataset

DataRow dr = ds.Tables[0].Rows[0];
Convert.ToInt32(dr[0]);

This is fairly common while it should of course be:

DataRow dr = ds.Tables[0].Rows[0];
(int)dr[0];

And yet another example of the ‘as’ keyword

You’ll see this quite often too:

if(o is MyOjbect)
{
MyObject mo = (MyObject)o;
}

While your method should be used by comparing the result against null. Well, first of all check that the existing reference isn’t null