Casting with as and is operators in C Sharp (C#)

Introduction

We use as and is to safely convert one type to another without errors. This helps check or change types in a friendly way.

When you want to check if an object is a certain type before using it.

When you want to convert an object to another type but avoid exceptions if it fails.

When working with different types in a collection and need to handle them differently.

When you want to write safer code that avoids crashes from wrong type conversions.

Syntax

C Sharp (C#)

Type variable = object as Type;
bool check = object is Type;

as tries to convert and returns null if it fails.

is checks if the object is a certain type and returns true or false.

Examples

Using as to convert obj to a string safely.

C Sharp (C#)

object obj = "hello";
string s = obj as string;  // s will be "hello"

as returns null because obj is not a string.

C Sharp (C#)

object obj = 123;
string s = obj as string;  // s will be null

is checks the type and returns false here.

C Sharp (C#)

object obj = 123;
bool isString = obj is string;  // false

is returns true because obj is a string.

C Sharp (C#)

object obj = "hello";
bool isString = obj is string;  // true

Sample Program

This program shows how as returns the string or null, and how is checks the type and prints messages accordingly.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        object obj1 = "Hello World";
        object obj2 = 42;

        // Using 'as' operator
        string str1 = obj1 as string;
        string str2 = obj2 as string;

        Console.WriteLine(str1 ?? "obj1 is not a string");
        Console.WriteLine(str2 ?? "obj2 is not a string");

        // Using 'is' operator
        if (obj1 is string)
            Console.WriteLine("obj1 is a string");
        else
            Console.WriteLine("obj1 is NOT a string");

        if (obj2 is string)
            Console.WriteLine("obj2 is a string");
        else
            Console.WriteLine("obj2 is NOT a string");
    }
}

Important Notes

Remember, as only works with reference types or nullable types.

Using is is a quick way to check type before casting.

Using as avoids exceptions but you must check for null after.

Summary

as tries to convert and returns null if it can't.

is checks if an object is a certain type and returns true or false.

Both help write safer code when working with different types.

Practice

1. What does the as operator do in C#?

easy

A. It tries to cast an object to a type and returns null if it fails.

B. It checks if an object is exactly a certain type and returns true or false.

C. It converts a value type to a string representation.

D. It throws an exception if the cast is invalid.

Solution

1. Step 1: Understand the as operator behavior

   The as operator attempts to cast an object to a specified type but returns null instead of throwing an exception if the cast fails.

2. Step 2: Compare with other options

   It checks if an object is exactly a certain type and returns true or false. describes the is operator, It converts a value type to a string representation. is unrelated, and It throws an exception if the cast is invalid. is incorrect because as does not throw exceptions.

3. Final Answer:

   It tries to cast an object to a type and returns null if it fails. -> Option A

4. Quick Check:

   as returns null on failure [OK]

Hint: Remember: as returns null, no exceptions [OK]

Common Mistakes:

• Confusing as with is
• Thinking as throws exceptions
• Assuming as works with value types

2. Which of the following is the correct syntax to check if an object obj is of type string using the is operator?

easy

A. if (obj == string) { /* code */ }

B. if (obj as string) { /* code */ }

C. if (obj is (string)) { /* code */ }

D. if (obj is string) { /* code */ }

Solution

1. Step 1: Recall is operator syntax

   The correct syntax to check type is if (obj is Type), so if (obj is string) is valid.

2. Step 2: Analyze other options

   if (obj as string) { /* code */ } uses as incorrectly in an if condition, if (obj == string) { /* code */ } compares object to type which is invalid, if (obj is (string)) { /* code */ } has unnecessary parentheses.

3. Final Answer:

   if (obj is string) { /* code */ } -> Option D

4. Quick Check:

   is syntax: obj is Type [OK]

Hint: Use is like: if (obj is Type) [OK]

Common Mistakes:

• Using as in if condition directly
• Comparing object to type with ==
• Adding unnecessary parentheses in is check

3. What is the output of the following code?

object obj = "hello";
string s = obj as string;
Console.WriteLine(s != null ? s.ToUpper() : "null");

medium

A. HELLO

B. null

C. hello

D. Runtime error

Solution

1. Step 1: Analyze the as cast

   The object obj holds a string "hello". Using as string casts it successfully, so s is "hello".

2. Step 2: Evaluate the conditional output

   Since s is not null, s.ToUpper() is called, producing "HELLO".

3. Final Answer:

   HELLO -> Option A

4. Quick Check:

   as cast success means uppercase output [OK]

Hint: If as cast succeeds, use the object; else null [OK]

Common Mistakes:

• Assuming as throws exception on failure
• Forgetting to check for null after as
• Confusing output case sensitivity

4. Identify the error in this code snippet:

object obj = 123;
string s = obj as string;
Console.WriteLine(s.Length);

medium

A. The is operator is used incorrectly.

B. The as cast will fail and s will be null, causing a null reference exception.

C. You cannot use as with value types like int.

D. The code will compile but print 3.

Solution

1. Step 1: Understand as cast with incompatible types

   Since obj holds an int (123), casting it as string returns null.

2. Step 2: Analyze the usage

   Since s is null, calling s.Length causes a null reference exception.

3. Final Answer:

   The as cast will fail and s will be null, causing a null reference exception. -> Option B

4. Quick Check:

   as returns null on failure; check before use [OK]

Hint: Always check for null after as cast before use [OK]

Common Mistakes:

• Assuming is fixes null issues
• Not checking s for null before accessing members
• Thinking as works with value types

5. Given the classes:

class Animal { }
class Dog : Animal { public string Bark() => "Woof!"; }

What is the safest way to call Bark() on an Animal reference a that might be a Dog?

hard

A. if (a is Dog) { Console.WriteLine(a.Bark()); }

B. Console.WriteLine(((Dog)a).Bark());

C. Dog d = a as Dog; if (d != null) Console.WriteLine(d.Bark());

D. Console.WriteLine(a.Bark());

Solution

1. Step 1: Understand safe casting with as

   Using as casts a to Dog safely, returning null if a is not a Dog.

2. Step 2: Check for null before calling Bark()

   Checking d != null ensures Bark() is called only if a is a Dog, avoiding exceptions.

3. Step 3: Compare with other options

   if (a is Dog) { Console.WriteLine(a.Bark()); } checks type but doesn't cast, so a.Bark() is invalid because Animal has no Bark(). Console.WriteLine(((Dog)a).Bark()); casts without check, risking exceptions. Console.WriteLine(a.Bark()); is invalid because Animal has no Bark().

4. Final Answer:

   Dog d = a as Dog; if (d != null) Console.WriteLine(d.Bark()); -> Option C

5. Quick Check:

   Use as + null check for safe cast [OK]

Hint: Use as then check null before method call [OK]

Common Mistakes:

• Casting without checking type first
• Calling methods on base type without override
• Using is then casting again unnecessarily