Why cant the compiler infer the type for me? (aka Smarter SmartEnumerable)

Question

I am using Jon Skeet's very clever SmartEnumerable. I recommend checking it out if you haven't already seen it.

The class is defined :

public class SmartEnumerable<T> : IEnumerable<SmartEnumerable<T>.Entry>

The constructor is :

public SmartEnumerable(IEnumerable<T> enumerable)

and you use it by saying :

new SmartEnumerable<Cat>(myCats);  // where myCats is IEnumerable<Cat>

Now I'd really like to have the compiler infer I've got an array of cats and be able to just say :

new SmartEnumerable(myCats);

However this gives me a compiler error :

The type arguments for method 'MiscUtil.Collections.SmartEnumerable.SmartEnumerable(System.Collections.Generic.IEnumerable)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

I'm not clear exactly why this is. is there any way around it. Why can't it see I'm using IEnumerable<Cat> and infer from that. Can i change anythin to make it recognize the type I'm using?

I'd really like some way to construct a SmartEnumerable without having to specify the type - because I'm primarily using it for UI in ASP.NET MVC where I don't always have includes for the types and rely on var to get me a reference. I end up having to include types just to be able to use SmartEnumerable - which reduces its elegance.

Oh and I would have just emailed John directly but he'll probably reply faster here anyway :-)

---

<font color=white>skeet skeet skeet, jon, jon, jon, jon skeet, skeet jon, skeetster, skeetmeister</font>

Answer 1

Try this code

public static class SmartEnumerable {
  public static SmartEnumerable<T> Create<T>(IEnumerable<T> source) {
    return new SmartEnumerable<T>(source);
  }
}

void Example() {
  IEnumerable<string> myCats = GetMyCats();
  var se = SmartEnumerable.Create(myCats);
}

Your code is failing because C# is not able to infer generic arguments on a constructor. But C# is more than capable of infering generic arguments on other methods.

In C# it's perfectly legal to have a class where the names only differ by the generic arguments. Foo and Foo<T> for example (under the hood they're actually different names). So the above sample will work for most scenarios. I personally use it whenever I define a generic class where the constructors take enough arguments to infer the full type.

Answer 2

I agree with JaredPar. I wanted to point out that you could also do an extension method:

public static SmartEnumerable<T> AsSmart<T>(this IEnumerable<T> source)
{
    return new SmartEnumerable<T>(source);
}

You would use it like so:

var smartEnumerable = myCats.AsSmart();

(The example sounds kind of funny)

Edit:

Per Jon Skeet, I renamed ToSmart to AsSmart.

Answer 3

A quick update - this is now available in MiscUtil itself. As per the example on the usage page:

// Old way
foreach (SmartEnumerable<string>.Entry entry in
                 new SmartEnumerable<string>(list))

// Better way
foreach (SmartEnumerable<string>.Entry entry in
                SmartEnumerable.Create(list))

// Best way (C# 3.0)
foreach (var entry in list.AsSmartEnumerable())