Difference Between Cast And OfType Operators

Jump To Right Section Show

When working with collections or sequences in C#, you may come across scenarios where you need to perform type conversions or filter elements based on their type. In such cases, LINQ provides two operators that can be used: Cast and OfType. Although both operators deal with type conversions, they have distinct functionalities and should be used appropriately depending on the situation.

In this article, we will explore the differences between the Cast() and OfType() operators in C# and understand when to use each of them.

Understanding the Cast() Operator

The Cast() operator is used to convert the elements of a collection or sequence to a specified type. It performs a runtime cast operation on each element, attempting to convert it to the desired type. However, it is important to note that the Cast() operator throws an InvalidCastException if it encounters an element that cannot be cast to the specified type.

Let’s consider an example to understand the usage of the Cast() operator. Suppose we have a collection of objects that need to be cast to a specific type:


ArrayList mixedList = new ArrayList();
mixedList.Add(1);
mixedList.Add("two");
mixedList.Add(3);

ArrayList mixedList = new ArrayList();

mixedList.Add(1);

mixedList.Add("two");

mixedList.Add(3);

If we want to convert the elements of this mixedList collection to integers, we can use the Cast() operator as follows:


IEnumerable<int> integers = mixedList.Cast<int>();

IEnumerable<int> integers = mixedList.Cast<int>();

Understanding the OfType() Operator

The OfType() operator, on the other hand, is used to filter elements of a collection or sequence based on a specified type. It returns only the elements that can be successfully cast to the desired type, discarding any elements that cannot be cast.

Let’s continue with the previous example and use the OfType() operator instead:


IEnumerable<int> integers = mixedList.OfType<int>();

IEnumerable<int> integers = mixedList.OfType<int>();

Unlike the Cast() operator, the OfType() operator will skip the element that cannot be cast to an integer ("two") and only return the elements that are successfully cast. In this case, the resulting sequence will be { 1, 3 }.

Choosing Between Cast() and OfType()

To summarize the differences between the Cast() and OfType() operators:

Cast() is used to explicitly convert the elements of a collection to a specified type. It throws an InvalidCastException if any element cannot be cast to the desired type.
OfType() is used to filter elements of a collection based on a specified type. It returns only the elements that can be successfully cast to the desired type and ignores any elements that cannot be cast.

When deciding which operator to use, consider the following guidelines:

Use the Cast() operator when you need to explicitly convert elements of a collection or sequence to a specific type and are confident that all elements can be cast without any exceptions.
Use the OfType() operator when you want to filter elements of a collection or sequence based on a specific type, and you are not concerned about elements that cannot be cast.

By understanding the differences between the Cast() and OfType() operators, you can make informed decisions and leverage the appropriate operator based on your specific requirements.

In conclusion, the Cast() and OfType() operators in LINQ provide convenient ways to work with type conversions and type-based filtering in collections or sequences. While the Cast() operator explicitly converts elements and throws an exception for invalid casts, the OfType() operator filters elements based on a specified type, ignoring elements that cannot be cast. By using these operators appropriately, you can efficiently manipulate and process data in a type-safe and concise manner.