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

      else

           // 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:

 

namespace Test

{

    public class Z

    {

        public virtual void Test()

        {

            System.Diagnostics.Debug.WriteLine("Z.Test");

        }

    }

 

    public class Y : X

    {

        public override void Test()

        {

            System.Diagnostics.Debug.WriteLine("Y.Test");

        }

    }

 

    public class X

    {      

        public virtual void Test()

        {

            System.Diagnostics.Debug.WriteLine("X.Test");       

        }

    }

 

    public class XX<T> where T : X

    {

        public virtual void Test()

        {

            System.Diagnostics.Debug.WriteLine("XX.Test");

        }

    }

 

    public partial class Form1 : Form

    {

                . . .

 

        private void button1_Click(object sender, EventArgs e)

        {

            XX<X> o1 = new XX<X>();

            o1.Test();

 

            XX<Y> o2 = new XX<Y>();

            o2.Test();

 

            // 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>();                

            o3.Test();

        }

    }

}

 

So, go ahead, let the compiler do the work – use these operators to write solid code!