Diferencia entre OfType <>() y comprobación de tipos en el caso de() de extensión

Question

Aparte de facilitar la lectura, ¿cuál es la diferencia entre las siguientes consultas LINQ y cuándo y por qué debería utilizar uno sobre el otro:

IEnumerable<T> items = listOfItems.Where(d => d is T).Cast<T>(); 

y

IEnumerable<T> items = listOfItems.OfType<T>(); 

actualización: Dang, lo siento introdujo algunos errores al tratar de simplificar mi problema

Answer 1

vamos a comparar tres métodos (prestar atención a los argumentos genéricos):

1. listOfItems.Where(t => t is T) pidió a IEnumerable<X> seguirá devolviendo IEnumerable<X> sólo filtra a contener sólo elementos del tipo T.

2. listOfItems.OfType<T>() llamada en IEnumerable<X> volverá IEnumerable<T> elementos que contienen que pueden ser colados para escribir T.

3. listOfItems.Cast<T>() llamada en IEnumerable<X> volverá IEnumerable<T> elementos que contienen emitidos para escribir T o lanzar una excepción si cualquiera de los elementos no se pueden convertir.

Y listOfItems.Where(d => d is T).Cast<T>() está haciendo básicamente lo mismo dos veces - Where filtros de todos los elementos que se T pero aún dejando el tipo IEnumerable<X> y luego intenta de nuevo Cast para echarlos a T pero esta vez regresan IEumerable<T>.

Answer 2

listOfItems.Where(d => d is T) devuelve un IEnumerable<U> (donde T es el tipo de los elementos de LISTOFITEMS), que contiene sólo los elementos de tipo T.

listOfItems.OfType<T>() devuelve un IEnumerable<T>.

Answer 3

Esencialmente, no hay diferencia en el compilado perfil de tiempo de ejecución del código compilado. OfType<T> devuelve un OfTypeIterator que internamente hace una prueba is y yield return s los que coinciden.

Answer 4

Si tomo algunas libertades con su ejemplo y la manivela que en LINQPad, aquí es lo que consigo:

Métodos

List<T> GetNumbers<T>(List<T> nums){ 
    return nums.Where(d => d is T).ToList<T>(); 
} 

List<T> GetNumbersOfType<T>(List<T> nums){ 
    return nums.OfType<T>().ToList<T>(); 
} 

IL

GetNumbers: 
IL_0000: ldarg.1  
IL_0001: ldnull  
IL_0002: ldftn  05 00 00 2B 
IL_0008: newobj  0A 00 00 0A 
IL_000D: call  06 00 00 2B 
IL_0012: call  07 00 00 2B 
IL_0017: ret   

GetNumbersOfType: 
IL_0000: ldarg.1  
IL_0001: call  08 00 00 2B 
IL_0006: call  07 00 00 2B 
IL_000B: ret 

I No soy un experto en IL, pero parece que el método GetNumbers (que usa el Where sintaxis) crea un nuevo objeto cada vez a través del bucle, por lo que probablemente consuma un poco más de memoria que el método GetNumbersOfType (que usa OfType).