There are a few keywords one should be aware of:
The as operator is similar to a cast but on any conversion failure null is returned as oppose to raising an exception. Note: it will not do the conversion (cast != data type conversion)!
Personally, I prefer not to use this operator, and, instead, use:
if (x is MyType)
// do the logic
// log error
As you can see, the is operator, which existed for some time, is used to check whether the run-time type of an object is compatible with a given type.
However, there are cases where as operator is useful. For example, I've personally used it in helper classes as described by code snippet below:
public class CompareHelper<T>
public int Compare(object data1, object data2) // similar to string.compare
int result = 0;
if (typeof(T) == typeof(bool))
result = Compare(data1 as bool, data2 as bool);
else if (typeof(T) == typeof(string))
result = Compare(data1 as string, data2 as string);
else if (typeof(T) == typeof(SomeCustomClass)) // perhaps this calls for some property call
result = Compare(data1 == null ? 0m : (data1 as SomeCustomClass).SomeDecimalProperty, data2 == null ? 0m : (data2 as SomeCustomClass).SomeDecimalProperty);
. . .
public int Compare(bool data1, bool data 2)
. . .
public int Compare(decimal data1, decimal data 2)
. . .
Finally, the new where keyword is used to specify constraints on the types that can be used as arguments for a type parameter defined in a generic declaration. For example:
public class Z
public virtual void Test()
public class Y : X
public override void Test()
public class X
public class XX<T> where T : X
public partial class Form1 : Form
. . .
private void button1_Click(object sender, EventArgs e)
XX<X> o1 = new XX<X>();
XX<Y> o2 = new XX<Y>();
// this line will fail at compile time with error:
// The type 'Test.Z' must be convertible to 'Test.X' in order to use
// it as parameter 'T' in the generic type or method 'Test.XX<T>'
XX<Z> o3 = new XX<Z>();
So, go ahead, let the compiler do the work – use these operators to write solid code!