当对象是IQueryable时返回IEnumerable

Question

I'm a bit confused about IEnumerable and IQueryable and interswapping of usages with Entity Framework. I've tried to do as much googling as I can on the subject but it hasn't seemed to help. So here's my situation.

I have a function( MyClass is an EntityObject ):

IEnumerable<MyClass> GetMyClasses(int id) {
    return GetQuery().Where(p => p.Id==id);
}

IQueryable<MyClass> GetQuery() {
    // returns an IQueryable list here
}

Now my question is. Given I'm returning an IEnumerable here rather than an IQueryable , when the statement is executed with a ToList() will the underlying SQL generated take into account the Id == id statement and so only return filter items or will it bring all the objects of the database into memory and perform the Where clause on that list?

Any helps, or even pointers to resources that describe this?

Answer 1

when the statement is executed with a ToList() will the underlying SQL generated take into account the Id == id statement and so only return filter items

The short answer is 'Yes'.

There is only Enumerable.ToList<T>(this IEnumumerable<T> e) and no counterpart for IQueryable<T>

Everything inside GetMyClasses method will be operated as IQueryable<T> , but the restrictions added after will be in-memory.

IEnumerable<MyClass> GetMyClasses(int id) {
    return GetQuery().Where(p => p.Id==id); // this always will work as IQueryable and handled by provider (in case of EF - the DB query will be performed)
}

IEnumerable<MyClass> MoreRestrictions(int id) {
     return GetMyClasses(id)
         .ToList(); // result list will be filtered by Id
}

IEnumerable<MyClass> MoreRestrictions(int id) {
     return GetMyClasses(id)
         .Where(x=>x.IsActive) // this where will be performed in memory on results filtered by Id.
         .ToList(); 
}

Methods ToList and Where is works like following

//There is only one implementation of ToList()
public List<T> ToList<T>(this IEnumerable<T> e) 
{
    var list = new List<T>();
    var enumerator = e.GetEnumerator();
    while (enumerator.MoveNext())
    {
        var item = e.Current;
        list.Add(item);
    }
    return list;
}

//Implementation for IEnumerable
public IEnumerable<T> Where<T>(this IEnumerable<T> e, Predicate predicate) 
{
    var enumerator = e.GetEnumerator();
    while (enumerator.MoveNext())
    {
        var item = e.Current;
        if (predicate(item))
            yield return item;
    }
}

//Implementation for IQueryable
public IQueryable<T> Where<T>(this IQueryable<T> e, Expression<Predicate> predicate) 
{
    MethodBase method = ...; // create generic method of Queryable.Where()
    return e.Provider
        .CreateQuery<T>(Expression.Call(null, method, e.Expression, Expression.Quote(predicate)));
}

The GetEnumerator method of IQueryable does query materialization.

Answer 2

You're making this too complicated. Consider the following:

public class Base { }

public class Derived : Base { }

public Base Method() {
    return GetOtherMethod();
}

public Derived GetOtherMethod()
{
    return new Derived ();
}

You're wondering about the characteristics of the return value from Method . It will be an instance of Derived , but you will only be able to use it as a Base unless you cast it to Derived .

So, your GetMyClasses will be returning an IQueryable<MyClass> that will be usable only as an IEnumerable<MyClass> .

Answer 3

This article is helpful: IQueryable vs IEnumerable in LINQ-to-SQL .

Quoting that article, 'As per the MSDN documentation, calls made on IQueryable operate by building up the internal expression tree instead. "These methods that extend IQueryable(Of T) do not perform any querying directly. Instead, their functionality is to build an Expression object, which is an expression tree that represents the cumulative query. "'

Expression trees are a very important construct in C# and on the .NET platform. (They are important in general, but C# makes them very useful.) To better understand the difference, I recommend reading about the differences between expressions and statements in the official C# 5.0 specification here. For advanced theoretical concepts that branch into lambda calculus, expressions enable support for methods as first-class objects. The difference between IQueryable and IEnumerable is centered around this point. IQueryable builds expression trees whereas IEnumerable does not, at least not in general terms for those of us who don't work in the secret labs of Microsoft.

Here is another very useful article that details the differences from a push vs. pull perspective. (By "push" vs. "pull," I am referring to direction of data flow. Reactive Programming Techniques for .NET and C#

Here is a very good article that details the differences between statement lambdas and expression lambdas and discusses the concepts of expression tress in greater depth: Revisiting C# delegates, expression trees, and lambda statements vs. lambda expressions. .