I am aware of two methods of casting types to IEnumerable from an Arraylist in Linq and wondering in which cases to use them?
e.g
IEnumerable<string> someCollection = arrayList.OfType<string>()
or
IEnumerable<string> someCollection = arrayList.Cast<string>()
What is the difference between these two methods and where should I apply each case?
OfType - return only the elements that can safely be cast to type x.
Cast - will try to cast all the elements into type x. if some of them are not from this type you will get InvalidCastException
EDIT for example:
object[] objs = new object[] { "12345", 12 };
objs.Cast<string>().ToArray(); //throws InvalidCastException
objs.OfType<string>().ToArray(); //return { "12345" }
Source: LINQ Tip: Enumerable.OfType - Solutionizing .NET
Fundamentally, Cast<T>() is implemented like this:
public IEnumerable<T> Cast<T>(this IEnumerable source)
{
foreach(object o in source)
yield return (T) o;
}
Using an explicit cast performs well, but will result in an InvalidCastException if the cast fails. A less efficient yet useful variation on this idea is OfType<T>():
public IEnumerable<T> OfType<T>(this IEnumerable source)
{
foreach(object o in source)
if(o is T t)
yield return t;
}
The returned enumeration will only include elements that can safely be cast to the specified type.
You should call Cast<string>() if you know that all of the items are strings.
If some of them aren't strings, you'll get an exception.
You should call OfType<string>() if you know that some of the items aren't strings and you don't want those items.
If some of them aren't strings, they won't be in the new IEnumerable<string>.
OfType<string>() will also skip null values. e.g: new string[] { "abc", "123", null, "" }.OfType<string>().Count() equals 3, whereas .Cast<string>().Count() would equal 4.
It should be noted that Cast(Of T) can be used on IEnumerable unlike other LINQ functions, so if there's ever a case where you need to use LINQ on a non-generic collection or list such as an ArrayList, you can use Cast(Of T) to cast to an IEnumerable(Of T) where LINQ can work.
Cast() will try to cast all elements of the collection (and will throw an exception if element is of the wrong type) while OfType() will return only elements of proper type.
OfType will filter the elements to return only the ones of the specified type. Cast will crash if an element cannot be cast to the target type.
Cast<T> will try to cast all items to the given type T. This cast could fail or throw an exception. OfType<T> will return a subset of the original collection and return only objects that are of type T.
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now相似问题
- How do I cast int to enum in C#?
- Direct casting vs 'as' operator?
- Multiple "order by" in LINQ
- What's the difference between the 'ref' and 'out' keywords?
- Best way to repeat a character in C#
- When to use .First and when to use .FirstOrDefault with LINQ?
- LINQ: When to use SingleOrDefault vs. FirstOrDefault() with filtering criteria
- IEnumerable vs List - What to Use? How do they work?
- DateTime vs DateTimeOffset
Cast<T>when you know for sure that the collection contains only typeTelements.OfType<T>is slower due to theistype check. If the collection is of typeIEnumerable<T>,Cast<T>will simply cast the whole collection asIEnumerable<T>and avoid enumerating it;OfType<T>will still enumerate. ref: stackoverflow.com/questions/11430570/….Cast<string>()does not throw when it is enumerated, it is not equivalent to.OfType<string>(). The reason is thatnullvalues are always skipped by.OfType<TResult>(). An example:new System.Collections.ArrayList { "abc", "def", null, "ghi", }.OfType<string>().Count()will give only3; the similar expression with.Cast<string>()evaluates to4.