What is the difference between casting and using "as" in C#?

If there is a difference, what is the difference between the two ways of doing the following cast?

In this case e is a GridViewRowEventArgs object.

GridView gv = (GridView)e.Row.FindControl("gv"); //first way

GridView gv2 = e.Row.FindControl("gv") as GridView; //second way

Solution 1:

The differences are:

• If a cast fails, it throws an InvalidCastException.
• If the as operator fails, it just returns a null reference.
• You can't use as with non-nullable value types (e.g. you can't do "o as int").
• The cast operator is also used for unboxing. (as can be used to unbox to a nullable value type.)
• The cast operator can also perform user-defined conversions.

EDIT: I've written elsewhere about when I feel it's appropriate to use which operator. That might be worth a read...

Solution 2:

What isn't mentioned in the above answers is intent -- why are you performing the conversion, and (more importantly) what happens on the lines after the conversion?

For example, I've seen code similar to the following a number of times:

if ((foo as SomeType).SomeMethod()) { /* ... */ }

This could be compared to the cast-using version:

if (((SomeType) foo).SomeMethod()) { /* ... */ }

So, which of these is better?

The cast is.

Using as will result in a NullReferenceException if the conversion fails.

Using a cast will result in an InvalidCastException if the conversion fails.

Now tell me, which is a more useful exception for debugging? A NullReferenceException, which could be produced by nearly anything, or an InvalidCastException, which lets you know what actually went wrong?

Thus, only use as if the conversion is actually optional (meaning that there must be a null check before using the variable). Otherwise, use a cast, thus making your intentions more explicit.

Solution 3:

The safe cast as

variable as type

does the same as

(variable is type) ? (type)variable : (type)null

and will not work for value types.