Once again, in this series of posts I look at the parts of the .NET Framework that may seem trivial, but can help improve your code by making it easier to write and maintain. The index of all my past little wonders posts can be found here.

We’ve seen how the Select() extension method lets you project a sequence from one type to a new type which is handy for getting just parts of items, or building new items.  But what happens when the items in the sequence are already the type you want, but the sequence itself is typed to an interface or super-type instead of the sub-type you need?

For example, you may have a sequence of Rectangle stored in an IEnumerable<Shape> and want to consider it an IEnumerable<Rectangle> sequence instead. 

Today we’ll look at two handy extension methods, Cast<TResult>() and OfType<TResult>() which help you with this task.

Cast<TResult>() – Attempt to cast all items to type TResult

So, the first thing we can do would be to attempt to create a sequence of TResult from every item in the source sequence.  Typically we’d do this if we had an IEnumerable<T> where we knew that every item was actually a TResult where TResult inherits/implements T.

For example, assume the typical Shape example classes:

   1: // abstract base class

   2: public abstract class Shape { }

   3:  

   4: // a basic rectangle

   5: public class Rectangle : Shape

   6: {

   7:     public int Widtgh { get; set; }

   8:     public int Height { get; set; }

   9: }

And let’s assume we have a sequence of Shape where every Shape is a Rectangle…

   1: var shapes = new List<Shape>

   2: {

   3:     new Rectangle { Width = 3, Height = 5 },

   4:     new Rectangle { Width = 10, Height = 13 },

   5:     // ... 

   6: };

To get the sequence of Shape as a sequence of Rectangle, of course, we could use a Select() clause, such as:

   1: // select each Shape, cast it to Rectangle

   2: var rectangles = shapes

   3:     .Select(s => (Rectangle)s)

   4:     .ToList();

But that’s a bit verbose, and fortunately there is already a facility built in and ready to use in the form of the Cast<TResult>() extension method:

   1: // cast each item to Rectangle and store in a List<Rectangle>

   2: var rectangles = shapes

   3:     .Cast<Rectangle>()

   4:     .ToList();

However, we should note that if anything in the list cannot be cast to a Rectangle, you will get an InvalidCastException thrown at runtime.  Thus, if our Shape sequence had a Circle in it, the call to Cast<Rectangle>() would have failed.  As such, you should only do this when you are reasonably sure of what the sequence actually contains (or are willing to handle an exception if you’re wrong).

Another handy use of Cast<TResult>() is using it to convert an IEnumerable to an IEnumerable<T>.  If you look at the signature, you’ll see that the Cast<TResult>() extension method actually extends the older, object-based IEnumerable interface instead of the newer, generic IEnumerable<T>. 

This is your gateway method for being able to use LINQ on older, non-generic sequences.  For example, consider the following:

   1: // the older, non-generic collections are sequence of object

   2: var shapes = new ArrayList

   3: {

   4:     new Rectangle { Width = 3, Height = 13 },

   5:     new Rectangle { Width = 10, Height = 20 },

   6:     // ...

   7: };

Since this is an older, object based collection, we cannot use the LINQ extension methods on it directly.  For example, if I wanted to query the Shape sequence for only those Rectangles whose Width is > 5, I can’t do this:

   1: // compiler error, Where() operates on IEnumerable<T>, not IEnumerable

   2: var bigRectangles = shapes.Where(r => r.Width > 5);

However, I can use Cast<Rectangle>() to treat my ArrayList as an IEnumerable<Rectangle> and then do the query!

   1: // ah, that’s better!

   2: var bigRectangles = shapes.Cast<Rectangle>().Where(r => r.Width > 5);

Or, if you prefer, in LINQ query expression syntax:

   1: var bigRectangles = from s in shapes.Cast<Rectangle>() 

   2:     where s.Width > 5 

   3:     select s;

One quick warning: Cast<TResult>() only attempts to cast, it won’t perform a cast conversion.  That is, consider this:

   1: var intList = new List<int> { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };

   2:  

   3: // casting ints to longs, this should work, right?

   4: var asLong = intList.Cast<long>().ToList();

Will the code above work? 

No, you’ll get a InvalidCastException. Remember that Cast<TResult>() is an extension of IEnumerable, thus it is a sequence of object, which means that it will box every int as an object as it enumerates over it, and there is no cast conversion from object to long, and thus the cast fails. 

In other words, a cast from int to long will succeed because there is a conversion from int to long.  But a cast from int to object to long will not, because you can only unbox an item by casting it to its exact type.

For more information on why cast-converting boxed values doesn’t work, see this post on The Dangers of Casting Boxed Values (here).

OfType<TResult>() – Filter sequence to only items of type TResult

So, we’ve seen how we can use Cast<TResult>() to change the type of our sequence, when we expect all the items of the sequence to be of a specific type.  But what do we do when a sequence contains many different types, and we are only concerned with a subset of a given type?

For example, what if a sequence of Shape contains Rectangle and Circle instances, and we just want to select all of the Rectangle instances?  Well, let’s say we had this sequence of Shape:

   1: var shapes = new List<Shape>

   2: {

   3:     new Rectangle { Width = 3, Height = 5 },

   4:     new Rectangle { Width = 10, Height = 13 },

   5:     new Circle { Radius = 10 },

   6:     new Square { Side = 13 },

   7:     // ...

   8: };

Well, we could get the rectangles using Select(), like:

   1: var onlyRectangles = shapes.Where(s => s is Rectangle).ToList();

But fortunately, an easier way has already been written for us in the form of the OfType<T>() extension method:

   1: // returns only a sequence of the shapes that are Rectangles

   2: var onlyRectangles = shapes.OfType<Rectangle>().ToList();

Now we have a sequence of only the Rectangles in the original sequence, we can also use this to chain other queries that depend on Rectangles, such as:

   1: // select only Rectangles, then filter to only those more than 

   2: // 5 units wide...

   3: var onlyBigRectangles = shapes.OfType<Rectangle>()

   4:     .Where(r => r.Width > 5)

   5:     .ToList();

The OfType<Rectangle>() will filter the sequence to only the items that are of type Rectangle (or a subclass of it), and that results in an IEnumerable<Rectangle>, we can then apply the other LINQ extension methods to query that list further.

Just as Cast<TResult>() is an extension method on IEnumerable (and not IEnumerable<T>), the same is true for OfType<T>().  This means that you can use OfType<TResult>() on object-based collections as well.

For example, given an ArrayList containing Shapes, as below:

   1: // object-based collections are a sequence of object

   2: var shapes = new ArrayList

   3: {

   4:     new Rectangle { Width = 3, Height = 5 },

   5:     new Rectangle { Width = 10, Height = 13 },

   6:     new Circle { Radius = 10 },

   7:     new Square { Side = 13 },

   8:     // ...

   9: };

We can use OfType<Rectangle> to filter the sequence to only Rectangle items (and subclasses), and then chain other LINQ expressions, since we will then be of type IEnumerable<Rectangle>:

   1: // OfType() converts the sequence of object to a new sequence 

   2: // containing only Rectangle or sub-types of Rectangle.

   3: var onlyBigRectangles = shapes.OfType<Rectangle>()

   4:     .Where(r => r.Width > 5)

   5:     .ToList();

Summary

So now we’ve seen two different ways to get a sequence of a superclass or interface down to a more specific sequence of a subclass or implementation.  The Cast<TResult>() method casts every item in the source sequence to type TResult, and the OfType<TResult>() method selects only those items in the source sequence that are of type TResult.

You can use these to downcast sequences, or adapt older types and sequences that only implement IEnumerable (such as DataTable, ArrayList, etc.).