Does LINQ “Query Syntax” Support Duck Typing?

Question

Regarding LINQ query syntax...

var foo = new List { 1, 2 };

var boo = from n in foo
            where n > 1
            select n;

Answer 1

There are a few features in C# that the compiler does structural type matching rather than nominal type matching. Examples include the foreach loop, query comprehension syntax (the select, where, etc), and await/async. For all of these features, the compiler is actually just looking for methods with certain names, not specific interfaces or classes.

The reason these features are not tied to specific interfaces is to decouple the language from the .NET framework implementation as much as possible. I suppose this would be considered a form of duck typing.

Eric Lippert explains the feature and reasoning much more thoroughly here.

I have noticed that the MSDN documentation is often wrong or incomplete about these features.

Answer 2

What you're missing is that List<T> implements IEnumerable<T>. Thus, "I always thought this syntax was limited to operating on IEnumerable" is technically true, though in a limited fashion. IQueryable implements IEnumerable as well, along with IList and arrays. Thus, you can perform linq queries against anything that implements IEnumerable.

Since Joker<> doesn't implement IEnumerable<>, your query attempt will fail. The Select<>(), Where<>(), etc. extension methods are built around IEnumerable<>. So, if you want to select from oof, you just need to update your definition of Joker<>

public class Joker<T> : IEnumerable<T>
{
  // (actually implement IEnumerable<T> functionality
}

(Edit: Answer did make some sense in the context of the originally-formatted question. Edited question makes my response obsolete)