Quelle est la manière appropriée de taper fortement le retour d'une fonction générique?

Question

J'écris une fonction de filtre pour renvoyer le type spécifique spécifié d'une plus grande collection de supertypes (objets par exemple). L'idée est que je vous donne un énumérable et que vous me rendiez toutes les cordes par exemple. vous pouvez l'écrire de cette façon sans médicaments génériques:

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 nous voulons revenir génériques, il y a plusieurs façons de s'y prendre.

En tant que port droit:

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

passe dans un 'exemple':

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

En fin de compte ce que je pense est plus propre:

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

Le second type serait appelé entièrement avec des paramètres (et déduire le type):

Filter(myList, "exampleString"); 

alors que la version finale, il obtiendrait appelé avec un spécificateur de type:

Filter<string>(myList); 

Quelle est la manière appropriée de typer le retour d'une fonction générique, où le type de retour n'implique pas automatiquement dans la signature? (Pourquoi?)

(Edit Note: Notre entrée n'est pas typé, par exemple IEnumerable <T> Au mieux, il serait IEnumerable Cette fonction retourne le Ts de toute la collection d'autres types...)

Answer 1

La méthode d'extension suivante inclus dans Linq fait exactement ce dont vous avez besoin:

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

Voici un exemple d'utilisation:

List<object> objects = //... 

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

Comme vous pouvez le voir, ils ont utilisé le paramètre générique comme spécificateur de type de retour. C'est plus simple et plus sûr que d'utiliser un type ou une chaîne et renvoyer une énumération non typée.

Answer 2

La manière la plus propre serait

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

Cela supprime toutes les fonctions de sécurité non de type. Vous pouvez ensuite convertir tout en IEnumerable une version générique non générique avec un appel coulé

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

Vous pouvez aussi faire en outre, il une méthode d'extension et de faire l'appel encore plus rationaliser.

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

EDIT

OP mentionné qu'ils ne veulent que de filtrer à des types spécifiques. Dans ce cas, vous pouvez simplement utiliser Enumerable.OfType

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