Casting: (NewType) vs. Object as NewType [duplicate]

What is actually the difference between these two casts?

SomeClass sc = (SomeClass)SomeObject;
SomeClass sc2 = SomeObject as SomeClass;

Normally, they should both be explicit casts to the specified type?

5.08.2008 15:42:30
See also…. This one was first, but that one has a good answer.
Jay Bazuzi 30.03.2010 21:35:26
You have posted the second oldest question that is a duplicate of another (the first one is locked)! Congratulations, I guess?
gparyani 9.10.2013 02:17:07
Which is funny because this one was posted 3 months earlier :) But the other one has more detailed answers.
Michael Stum♦ 9.10.2013 02:25:42

The former will throw an exception if the source type can't be cast to the target type. The latter will result in sc2 being a null reference, but no exception.


My original answer is certainly the most pronounced difference, but as Eric Lippert points out, it's not the only one. Other differences include:

  • You can't use the 'as' operator to cast to a type that doesn't accept 'null' as a value
  • You can't use 'as' to convert things, like numbers to a different representation (float to int, for example).

And finally, using 'as' vs. the cast operator, you're also saying "I'm not sure if this will succeed."

9.10.2009 05:33:21

The parenthetical cast throws an exception if the cast attempt fails. The "as" cast returns null if the cast attempt fails.

5.08.2008 15:45:06

They'll throw different exceptions.
() : NullReferenceException
as : InvalidCastException
Which could help for debugging.

The "as" keyword attempts to cast the object and if the cast fails, null is returned silently. The () cast operator will throw an exception immediately if the cast fails.

"Only use the C# "as" keyword where you are expecting the cast to fail in a non-exceptional case. If you are counting on a cast to succeed and are unprepared to receive any object that would fail, you should use the () cast operator so that an appropriate and helpful exception is thrown."

For code examples and a further explanation:

5.08.2008 15:49:34
(-1) as won't throw an InvalidCastException.
Keith 18.09.2008 11:03:09

Also note that you can only use the as keyword with a reference type or a nullable type


double d = 5.34;
int i = d as int;

will not compile

double d = 5.34;
int i = (int)d;

will compile.

5.08.2008 16:15:38
because a casting does not convert
CiNN 25.10.2008 09:32:00

Here is a good way to remember the process that each of them follow that I use when trying to decide which is better for my circumstance.

DateTime i = (DateTime)value;
// is like doing
DateTime i = value is DateTime ? value as DateTime : throw new Exception(...);

and the next should be easy to guess what it does

DateTime i = value as DateTime;

in the first case if the value cannot be cast than an exception is thrown in the second case if the value cannot be cast, i is set to null.

So in the first case a hard stop is made if the cast fails in the second cast a soft stop is made and you might encounter a NullReferenceException later on.

5.08.2008 17:46:00

It's like the difference between Parse and TryParse. You use TryParse when you expect it might fail, but when you have strong assurance it won't fail you use Parse.

8.08.2008 12:00:01

To expand on Rytmis's comment, you can't use the as keyword for structs (Value Types), as they have no null value.

23.05.2017 12:25:36

Typecasting using "as" is of course much faster when the cast fails, as it avoids the expense of throwing an exception.

But it is not faster when the cast succeeds. The graph at is misleading because it doesn't explain what it's measuring.

The bottom line is:

  • If you expect the cast to succeed (i.e. a failure would be exceptional), use a cast.

  • If you don't know if it will succeed, use the "as" operator and test the result for null.

18.09.2008 10:58:12

For those of you with VB.NET experience, (type) is the same as DirectCast and "as type" is the same as TryCast.

16.09.2008 21:55:28

All of this applies to reference types, value types cannot use the as keyword as they cannot be null.

//if I know that SomeObject is an instance of SomeClass
SomeClass sc = (SomeClass) someObject;

//if SomeObject *might* be SomeClass
SomeClass sc2 = someObject as SomeClass;

The cast syntax is quicker, but only when successful, it's much slower to fail.

Best practice is to use as when you don't know the type:

//we need to know what someObject is
SomeClass sc;
SomeOtherClass soc;

//use as to find the right type
if( ( sc = someObject as SomeClass ) != null ) 
    //do something with sc
else if ( ( soc = someObject as SomeOtherClass ) != null ) 
    //do something with soc

However if you are absolutely sure that someObject is an instance of SomeClass then use cast.

In .Net 2 or above generics mean that you very rarely need to have an un-typed instance of a reference class, so the latter is less often used.

19.09.2008 12:54:56

A difference between the two approaches is that the the first ((SomeClass)obj) may cause a type converter to be called.

7.11.2008 23:46:49

Well the 'as' operator "helps" you bury your problem way lower because when it is provided an incompatible instance it will return null, maybe you'll pass that to a method which will pass it to another and so on and finally you'll get a NullReferenceException which will make your debugging harder.

Don't abuse it. The direct cast operator is better in 99% of the cases.

28.10.2010 09:21:44
Very sound advice here. Readers, please consider this.
mbadawi23 1.09.2017 22:06:21