User Name:


User Email:




This information will only be saved for the purposes of communicating with those who have provided this information voluntarily regarding our services.We will never sell your name or email address to anyone.
© 2018 - First Crazy Developer (Abhishek Kumar)
  

crazydeveloper The Is and As Operators in C#

Type Casting is the mechanism to convert one data type to another. While type casting of one data type to another, we get exception if the previous one data type is not compatible with the new data type. To avoid this exception, we have IS and AS operator in C# for safe type casting. Let's understand how to use both of them.

IS operator check for Object Type.

AS operator convert between compatible type Object.

Introduction 

Look at the example given below:

Circle c = new Circle(32);

object o = c;

int i = (int)o;        // it compiles okay but throws an exception at runtime

Here the runtime is more suspicious; if the type of object in memory does not match the cast, the runtime will throw an InvalidCastException. We should be prepared to catch this exception and handle it appropriately if it occurs. However, catching an exception and attempting to recover in the event that the type of an object is not what we expected it to be is a rather cumbersome approach. C# provides two more very useful operators that can help us to perform casting in a much more elegant manner by using the "is" and "as" operators. Let's have some discussion of the operators.

is Operator

The "is" operator is used to check whether the run-time type of an object is compatible with a given type or not. In other words, we use the "is" operator to verify that the type of an object is what we expect it to be. Let's look at its syntax: 

expression is type 

Example of the "is" operator:

using System;
class Class1
{
}
class Class2
{
}
public class IsTest
{
    public static void Test(object o)
    {
        Class1 a;
        Class2 b;
        if (o is Class1)
        {
            Console.WriteLine("o is Class1");
            a = (Class1)o;
        }
        else if (o is Class2)
        {
            Console.WriteLine("o is Class2");
            b = (Class2)o;
        }
        else
        {
            Console.WriteLine("o is neither Class1 nor Class2.");
        }
    }
    public static void Main()
    {
        Class1 c1 = new Class1();
        Class2 c2 = new Class2();
        Test(c1);
        Test(c2);
        Test("Passing String Value instead of class");
        Console.ReadKey();
    }
}

 

In the above example, I'll be checking whether object o is a class or not. If the argument passed is not a class then the application will jump to the message 'o is neither class1 nor class2'. 

as Operator 

The "as" operator is used to perform conversions between compatible types. Actually, the "as" operator fulfills a similar role like "is" but in a slightly truncated manner. Let's look at its syntax: 

expression as type 

Example of the "as" operator:

using System;
class Class1
{
}
class Class2
{
}
public class IsTest
{
    public static void Main()
    {
        object[] myObjects = new object[6];
        myObjects[0] = new Class1();
        myObjects[1] = new Class2();
        myObjects[2] = "string";
        myObjects[3] = 32;
        myObjects[4] = null;
        for (int i = 0; i < myObjects.Length; ++i)
        {
            string s = myObjects[i] as string;
            Console.Write("{0}:", i);
            if (s != null)
                Console.WriteLine("'" + s + "'");
            else
                Console.WriteLine("not a string");
        }
        Console.ReadKey();
    }


In the above example, each and every value is being cast to a string using the "as" operator and assigned to a string variable which is shown on the console.

So, that's all about the "is" and "as" operators. Thanks for joining this article.


crazydeveloper Home Page 30 April 2015

Become a Fan