Meskipun C dibuat untuk memprogram sistem dan jaringan komputer namun bahasa ini juga sering digunakan dalam mengembangkan software aplikasi. C juga banyak dipakai oleh berbagai jenis platform sistem operasi dan arsitektur komputer, bahkan terdapat beberepa compiler yang sangat populer telah tersedia.
C adalah huruf ketiga dalam alfabet Latin. Dalam bahasa Indonesia, huruf ini disebut ce (dibaca [tʃe]).
With the "classic" method, if the cast fails, an InvalidCastException
is thrown. With the as
method, it results in null
, which can be checked for, and avoid an exception being thrown.
Also, you can only use as
with reference types, so if you are typecasting to a value type, you must still use the "classic" method.
Note:
The as
method can only be used for types that can be assigned a null
value. That use to only mean reference types, but when .NET 2.0 came out, it introduced the concept of a nullable value type. Since these types can be assigned a null
value, they are valid to use with the as
operator.
Null comparison is MUCH faster than throwing and catching exception. Exceptions have significant overhead - stack trace must be assembled etc.
Exceptions should represent an unexpected state, which often doesn't represent the situation (which is when as
works better).
In some cases, it's easily to deal with a null
than an exception. In particular, the coalescing operator is handy:
SomeClass someObject = (obj as SomeClass) ?? new SomeClass();
It also simplifies code where you are (not using polymorphism, and) branching based on the type of an object:
ClassA a;
ClassB b;
if ((a = obj as ClassA) != null)
{
// use a
}
else if ((b = obj as ClassB) != null)
{
// use b
}
As specified on the MSDN page, the as
operator is equivalent to:
expression is type ? (type)expression : (type)null
which avoids the exception completely in favour of a faster type test, but also limits its use to types that support null
(reference types and Nullable<T>
).
The as
operator is useful in a couple of circumstances.
null
The 3rd point is subtle but important. There is not a 1-1 mapping between which casts will succeed with the cast operator and those which will succeed with the as
operator. The as
operator is strictly limited to CLR conversions and will not consider user defined conversions (the cast operator will).
Specifically the as
operator only allows for the following (from section 7.9.11 of the C# lang spec)
The as
keyword is useful when you genuinely don't know what type the variable might be. If you have a single function that will follow different code paths depending upon the actual type of the parameter, then you have two choices:
First, using a normal cast:
if(myObj is string)
{
string value = (string)myObj;
... do something
}
else if(myObj is MyClass)
{
MyClass = (MyClass)myObj;
}
This requires that you check the type of the object using is
so that you don't try to cast it to something that will fail. This is also slightly redundant, as the is
-type checking is done again in the cast (so that it can throw the exception if required).
The alternative is to use as
.
string myString = myObj as string;
MyClass myClass = myObj as MyClass;
if(myString != null)
{
}
else if(myClass != null)
{
}
This makes the code somewhat shorter and also eliminates the redundant type checking.
I think the best 'rule' would be to only use the 'as' keyword when it's expected that your subject won't be the object you're casting to:
var x = GiveMeSomething();
var subject = x as String;
if(subject != null)
{
// do what you want with a string
}
else
{
// do what you want with NOT a string
}
However, when your subject SHOULD be of the type you're casting to, use a 'classic cast', as you call it. Because if it isn't the type you're expecting, you'll get an exception which fits the exceptional situation.
using as will return null if not a valid cast which allows you to do other things besides wrapping the cast in a try/catch. I hate classic cast. I always use as cast if i'm not sure. Plus, exceptions are expensive. Null checks are not.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With