What is the appropriate way to strongly type the return of a generic function?

Question

I'm writing a filter function to return the specific type specified out of a larger collection of supertypes (objects for example). The idea is I give you an enumerable and you return me all the strings for example. you can write it this way without generics:

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;
}

if we want to return generics there are a few different ways to go about it.

As a straight port:

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

Pass in an 'example':

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

Ultimately what I think is cleanest:

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

The second type would be called entirely with parameters (and infer the type):

Filter(myList, "exampleString");

where as the final version there would get called with a type specifier:

Filter<string>(myList);

What is the appropriate way to strongly type the return of a generic function, where the return type isn't automatically implied in the signature? (why?)

(Edit Note: Our input is NOT typed, e.g. IEnumerable<T>. At best it would be IEnumerable. This function is returning the Ts out of the whole collection of other types.)

Answer 1

The following extension method included in Linq does exactly what you need:

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

Here is a usage example:

List<object> objects = //...

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

As you can see, they used the generic parameter as the return type specifier. This is simpler and safer than using a Type or a string and return a non type safe enumeration.

Answer 2

The cleanest way would be

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

This removes all non-type safe functions. You can then convert any non-generic IEnumerable into a generic version with a cast call

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

You could also additionally make it an extension method and make the call even more streamline.

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

EDIT

OP mentioned they only want to filter to specific types. In that case you can just use Enumerable.OfType

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

Answer 3

I generally prefer the final version - it specifies all the relevant information and nothing else. Given the version with parameters, if you were new to the code wouldn't you expect the value of the parameter to be meaningful, rather than just the type?

Very occasionally this "dummy parameter" pattern is useful, but I'd generally steer clear of it - or at the very least provide an overload which didn't require it.

Answer 4

Hi

this is my 2 cents. I'm a bit confused about what you are trying to filter. IEnumerable is non-generic, so how are you going to filter a non-generic source and return a result of IEnuerable.

I think the cleanest is

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

you can even put in generic type checks, if you know what kind of types your filter of T will be, e.g. only classes or objects of a certain interface or base class, or value types..like so.

public static IEnumerable<T> Filter<T>(IEnumerable<T> source) where T : class
public static IEnumerable<T> Filter<T>(IEnumerable<T> source) where T : struct

Answer 5

If you are using framework 3.5, this is already implemented in IEnumerable:

IEnumerable<string> s = someList.OfType<string>()

Answer 6

It's clear (to me, at least) that you'd want the final version:

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

by process of reduction, if nothing else.

The first version:

IEnumerable<T> Filter<T>(IEnumerable source, Type type)

has to deal with craziness where I pass in a Type that does not match the constraint:

The second version:

IEnumerable<T> Filter<T>(IEnumerable source, T type)

makes me construct an example, which may be expensive or otherwise unavailable for construction. Also, what if I pass in null (in either case)?

As an aside, for single constraints, I think the type parameter should be T. You can get away with TResult if it's the return of a function - like Func<TResult>, but otherwise it's just more typing with less clarity.

Answer 7

I think this is pretty much what you want.

public static IEnumerable<T> OfType<T>(IEnumerable source) {
    foreach (object obj in source)
        if (obj is T)
            yield return (T)obj;
}

A slightly more complex version but (probably) slightly faster would be

public static IEnumerable<T> OfType<T>(IEnumerable source) {
    foreach (object obj in source) {
        T result = obj as T;
        if (result != null)
            yield return result;
    }
}