¿Cuál es la forma adecuada de escribir con fuerza el retorno de una función genérica?

Question

Estoy escribiendo una función de filtro para devolver el tipo específico especificado de una colección más grande de supertipos (objetos, por ejemplo). La idea es que te dé un enumerable y me devuelvas todos los hilos, por ejemplo. se puede escribir de esta manera sin genéricos:

public static IEnumerable Filter(IEnumerable source, Type type) 
{ 
    List<object> results = new List<object>(); 

    foreach(object o in source) 
    { 
     if(o != null && o.GetType() == type) 
     { 
      results.Add(o); 
     } 
    } 

    return results; 
} 

si queremos volver genéricos hay algunas maneras diferentes de ir sobre él.

Como puerto recta:

public static IEnumerable<TResult> Filter<TResult> 
          (IEnumerable source, Type type) 

Pass en un 'ejemplo':

IEnumerable<TResult> Filter<TResult> 
    (IEnumerable source, TResult resultType) 

En última instancia lo que creo que es más limpio:

public static IEnumerable<T> Filter<T>(IEnumerable source) 

El segundo tipo se llama completamente con parámetros (e inferir el tipo):

Filter(myList, "exampleString"); 

en tanto que la versión final no se obtendría llamada con un especificador de tipo:

Filter<string>(myList); 

¿Cuál es la forma apropiada de escribir fuertemente el retorno de una función genérica, donde el tipo de retorno no se implica de forma automática en la firma? (¿Por qué?)

(Editar Nota: Nuestra entrada no se escribe, por ejemplo, IEnumerable <T> En el mejor sería IEnumerable Esta función devuelve el Ts de toda la colección de otros tipos...)

Answer 1

El siguiente método de extensión incluido en LINQ hace exactamente lo que necesita:

IEnumerable<T> OfType<T>(this IEnumerable enumerable); 

Aquí está un ejemplo de uso:

List<object> objects = //... 

foreach(string str in objects.OfType<string>()) 
{ 
    //... 
} 

Como puede ver, usaron el parámetro genérico como el especificador de tipo de retorno. Esto es más simple y seguro que usar un tipo o una cadena y devolver una enumeración segura que no sea de tipo.

Answer 2

La manera más limpia sería

public static IEnumerable<T> Filter<T>(IEnumerable<T> source) 

Esto elimina todas las funciones de seguridad no tipo. A continuación, puede convertir cualquier IEnumerable no genérica en una versión genérica con una llamada elenco

IEnumerable enumerable = GetMyEnumerable(); 
var filtered = Filter(enumerable.Cast<string>()); 

También podría, además, que sea un método de extensión y hacer la llamada a simplificar aún más.

public static IEnumerable<T> Filter<T>(this IEnumerable<T> source) 
... 
var filtered = GetMyEnumerable().Cast<string>().Filter(); 

EDITAR

OP mencionó que sólo quieren filtrar a tipos específicos. En ese caso, puedes usar Enumerable.OfType

var filtered = GetMyEnumerable().OfType<SomeType>();