Test in a live environment
Test in production without watermarks.
Works wherever you need it to.
Programming in C# often involves working with different types of data. Sometimes, we need to check if an object
is of a certain type or attempt to convert it to that type. That's where the as
operator keyword comes in handy. Along with its close relative, the is operator
aids in type testing and conversions. In this tutorial, we will explore the intricacies of this operator and its use cases.
as
operatorThe as
operator keyword in C# is a binary operator used to perform certain conversions between compatible reference types or nullable types. The following code provides a simple demonstration:
object myObj = "Hello, World!";
string myStr = myObj as string;
object myObj = "Hello, World!";
string myStr = myObj as string;
Dim myObj As Object = "Hello, World!"
Dim myStr As String = TryCast(myObj, String)
In the code above, myObj
is an object of type object
(the base type for all types in C#). We are uncertain of its underlying type at compile time. The as
operator is used to attempt to treat myObj
as a string
. If successful, myStr
will hold the string value. Otherwise, it will hold a null value
.
While both the as-operator and explicit cast serve similar purposes, there's a key distinction. If an explicit cast fails, it throws an exception. On the other hand, if the as
operator's attempt at conversion from one type to another fails, the operator returns a null value
instead of raising an exception. Let's understand this with the following code example:
object someValue = 12345;
// Using explicit cast
string castResult;
try {
castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
castResult = null;
}
// Using the as operator
string asResult = someValue as string; // No exception, but asResult will be null since the cast fails.
object someValue = 12345;
// Using explicit cast
string castResult;
try {
castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
castResult = null;
}
// Using the as operator
string asResult = someValue as string; // No exception, but asResult will be null since the cast fails.
Dim someValue As Object = 12345
' Using explicit cast
Dim castResult As String
Try
castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
castResult = Nothing
End Try
' Using the as operator
Dim asResult As String = TryCast(someValue, String) ' No exception, but asResult will be null since the cast fails.
As evident, using the as
operator can often be safer as you avoid potential runtime errors.
Often, the as operator
is used in conjunction with the is operator
for type testing before attempting a conversion. The is operator
checks if the provided object is of the given type and returns true if it is, otherwise, it returns false.
The following code example illustrates this:
object testObject = "This is a string";
if(testObject is string) {
string result = testObject as string;
Console.WriteLine(result);
} else {
Console.WriteLine("Not a string");
}
object testObject = "This is a string";
if(testObject is string) {
string result = testObject as string;
Console.WriteLine(result);
} else {
Console.WriteLine("Not a string");
}
Dim testObject As Object = "This is a string"
If TypeOf testObject Is String Then
Dim result As String = TryCast(testObject, String)
Console.WriteLine(result)
Else
Console.WriteLine("Not a string")
End If
With the introduction of pattern matching in later versions of C#, the is
operator can also perform certain actions if the type test passes. This often reduces the need for using the as
operator.
One of the special cases where the as
operator is invaluable is with nullable value types. Value types (like int
, double
, etc.) cannot be assigned a null value
. However, by making them nullable, you can assign null to them. The as
operator can be used to attempt conversion to a nullable value type:
int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;
int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;
Dim nullableInt? As Integer = 10
Dim objInt As Object = nullableInt
Dim resultInt? As Integer = CType(objInt, Integer?)
The as
operator supports both reference conversions (between related reference types) and user-defined conversions. User-defined conversions are those conversions that are defined using special conversion methods in your classes.
Consider the following code of a user-defined conversion:
class Sample {
public static implicit operator string(Sample s) {
return "Converted to String";
}
}
Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;
class Sample {
public static implicit operator string(Sample s) {
return "Converted to String";
}
}
Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;
Friend Class Sample
Public Shared Widening Operator CType(ByVal s As Sample) As String
Return "Converted to String"
End Operator
End Class
Private sampleObject As New Sample()
Private conversionResult As String = TryCast(sampleObject, String)
Here, the user-defined conversion method allows an object of type Sample
to be treated as a string
.
Remember that the as
operator cannot be used with value types (unless dealing with nullable value types) or with user-defined conversions that involve an explicit method.
Boxing is the process of converting a value-type instance to an object reference. This is made possible because every value type implicitly inherits from an object
. When you box a value type, you wrap it inside an object
.
Consider the following code for boxing conversions:
int intValue = 42;
object boxedValue = intValue;
int intValue = 42;
object boxedValue = intValue;
Dim intValue As Integer = 42
Dim boxedValue As Object = intValue
Here, the intValue
is boxed into an object
.
Unboxing is the reverse process of boxing, i.e., extracting the value type from the object
. The as
operator can be used to safely unbox values, particularly when you aren't sure if the object
holds the value type you're expecting. If the unboxing is unsuccessful, the expression result will be null.
Consider the following example for unboxing conversions:
object obj = 42;
int? result = obj as int?;
object obj = 42;
int? result = obj as int?;
Dim obj As Object = 42
Dim result? As Integer = CType(obj, Integer?)
Arrays are reference types in C#. Sometimes, you might need to determine if an object
is a specific type of array and then work with it. The as
operator can help here too.
Consider the following code:
object[] arrayObject = new string[] { "one", "two", "three" };
string[] stringArray = arrayObject as string[];
object[] arrayObject = new string[] { "one", "two", "three" };
string[] stringArray = arrayObject as string[];
Dim arrayObject() As Object = New String() { "one", "two", "three" }
Dim stringArray() As String = TryCast(arrayObject, String())
In the code above, arrayObject
is an array of objects but actually holds strings. Using the as
operator, you can safely attempt to treat it as an array of strings.
as
with LINQLanguage Integrated Query (LINQ - Microsoft Documentation) is a powerful feature in C# that allows you to query collections in a SQL-like manner. Sometimes, you might retrieve objects of mixed types in a collection and want to filter out specific types. Here, the as
-operator can be very handy.
For instance, consider a list of objects containing both strings and integers. If you wanted to retrieve only the strings, you could use the as
operator in conjunction with LINQ:
var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
.Select(item => item as string)
.Where(item => item != null)
.ToList();
var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
.Select(item => item as string)
.Where(item => item != null)
.ToList();
Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).ToList()
Iron Suite Solutions for C# Developers is a suite of high-quality tools that empower C# developers to seamlessly integrate functionalities such as PDF manipulation, Excel handling, Optical Character Recognition (OCR), and barcode generation and reading. These tools, like our earlier discussion on the as
and is
operators, are pivotal in amplifying a developer's efficiency in building robust applications.
IronPDF allows developers to generate, manipulate, and read PDF files within their C# applications. Considering the relevance to our topic, suppose you had a reference type that held some data, and you wanted to convert this data to a report or document. IronPDF
can take your application's output and, in a manner akin to type conversion, translate it into a well-formatted PDF document.
Handling Excel files is a frequent requirement in many software applications. IronXL for Excel Operations
provides developers with the ability to read, edit, and create Excel spreadsheets without needing to rely on Office Interop. In the context of our discussion on type conversions, think of IronXL
as a tool that allows you to convert data structures or database entries in C# into Excel formats seamlessly.
Optical Character Recognition with IronOCR
is an optical character recognition tool that permits developers to read and interpret text from images. Bridging this to our tutorial, it's similar to converting an object
(in this case, an image) to a more specific type (string
or textual data) using advanced recognition capabilities.
In many commercial applications, handling barcodes is indispensable. IronBarcode Tool for Barcode Processing
aids developers in generating, reading, and decoding barcodes in C# applications. Relating to our discussion on type conversions, IronBarcode
can be viewed as a tool that translates visual barcode data (a form of object
) into more specific, usable data types, such as strings or product details.
Each product within the Iron Suite Offerings is a testament to the flexibility and power C# offers, especially when tied into our discussion on type conversions and type checking. These tools, like the as
and is
operators, provide developers with the capability to convert and process data efficiently.
If you're considering integrating any of these tools into your projects, it's worth noting that each product license starts from $749 and every product offers a free trial of Iron Suite Tools. For those looking for a comprehensive solution, Iron Suite
provides an enticing offer: you can acquire the Iron Suite license for the price of just two products.
9 .NET API products for your office documents