Partial generic type inference possible in C#?

by

I wanted to create an extension method that could enumerate over a list of things, and return a list of those things that were of a certain type. It would look like this:

listOfFruits.ThatAre<Banana>().Where(banana => banana.Peel != Color.Black) ...

Sadly, this is not possible. The proposed signature for this extension method would have looked like:

public static IEnumerable<TResult> ThatAre<TSource, TResult>
    (this IEnumerable<TSource> source) where TResult : TSource

… and the call to ThatAre<> fails because both type arguments need to be specified, even though TSource may be inferred from the usage.

Following the advice in other answers, I created two functions: one which captures the source, and another which allows callers to express the result:

public static ThatAreWrapper<TSource> That<TSource>
    (this IEnumerable<TSource> source)
{
    return new ThatAreWrapper<TSource>(source);
}

public class ThatAreWrapper<TSource>
{
    private readonly IEnumerable<TSource> SourceCollection;
    public ThatAreWrapper(IEnumerable<TSource> source)
    {
        SourceCollection = source;
    }
    public IEnumerable<TResult> Are<TResult>() where TResult : TSource
    {
        foreach (var sourceItem in SourceCollection)
            if (sourceItem is TResult) yield return (TResult)sourceItem;
        }
    }
}

This results in the following calling code:

listOfFruits.That().Are<Banana>().Where(banana => banana.Peel != Color.Black) ...

… which isn’t bad.

Notice that because of the generic type constraints, the following code:

listOfFruits.That().Are<Truck>().Where(truck => truck.Horn.IsBroken) ...

will fail to compile at the Are() step, since Trucks are not Fruits. This beats the provided .OfType<> function: 

listOfFruits.OfType<Truck>().Where(truck => truck.Horn.IsBroken) ...

This compiles, but always yields zero results and indeed doesn’t make any sense to try. It’s much nicer to let the compiler help you spot these things.

More Related Contents:

  1. Why can’t the C# constructor infer type?
  2. Why must I provide explicitly generic parameter types While the compiler should infer the type?
  3. No type inference with generic extension method
  4. C# 3.0 generic type inference – passing a delegate as a function parameter
  5. Generics: Why can’t the compiler infer the type arguments in this case?
  6. KeyValuePair with generic values [closed]
  7. Why doesn’t C# infer my generic types?
  8. Why isn’t there generic variance for classes in C# 4.0?
  9. Generics and casting – cannot cast inherited class to base class
  10. What is the best way to clone/deep copy a .NET generic Dictionary?
  11. Generic constraints, where T : struct and where T : class
  12. Nullable type issue with ?: Conditional Operator
  13. Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates? [duplicate]
  14. Calling a static method on a generic type parameter
  15. How do I make the return type of a method generic?
  16. Partial type inference
  17. explicitly cast generic type parameters to any interface
  18. Why does the c# compiler emit Activator.CreateInstance when calling new in with a generic type with a new() constraint?
  19. .NET – Convert Generic Collection to DataTable
  20. Using Statement with Generics: using ISet = System.Collections.Generic.ISet
  21. C# Generic Type Inference With Multiple Types
  22. SortedList, SortedDictionary and Dictionary
  23. How do I check if a given value is a generic list?
  24. Declare a generic type instance dynamically [duplicate]
  25. Creating a Math library using Generics in C#
  26. Accessing properties through Generic type parameter
  27. Why doesn’t C# support implied generic types on class constructors?
  28. Creating a generic method in C#
  29. C# generic methods, type parameters in new() constructor constraint
  30. Convert DataTable to Generic List in C#

Leave a Comment