IQueryable and IQueryable#

IQueryable and IQueryable are used to build specific query against a specific data source, like SQL Server, etc.:

1
namespace System.Linq
2
{
3
    public interface IQueryable : IEnumerable
4
    {
5
        Type ElementType { get; }
6

7
        Expression Expression { get; }
8

9
        IQueryProvider Provider { get; }
10
    }
11

12
    public interface IQueryable<out T> : IEnumerable<T>, IQueryable, IEnumerable
13
    {
14
    }
15
}

Check this post for the meaning of out keyword.

The ElementType property is easy to understand. Generally speaking, an IQueryable is an IEnumerable with an expression and query provider:

• Expression property returns an Expression object to express the meaning of the current query;
• Provider property returns an IQueryProvider, which is able to execute the current query on the specific data source.

The concept of expression and query provider will be covered in later posts. This post will concentrate on IQueryable itself.

IQueryable and IQueryable extensions#

Just like a bunch of extension methods for IEnumerable and IEnumerable are defined on System.Linq.Enumerable class, the System.Linq.Queryable class contians the extension methods for IQueryable and IQueryable:

The underlined methods are extension methods for the non-generic IEnumerbale and IQueryable interfaces. Methods in [] are normal static methods. And the AsQueryable() methods in {} are also special, they are extension methods for IEnumerable and IEnumerable.

Please notice that, since IQuerayable implements IEnumerable, IEnumerable’s extension methods are also IQuerayable’s extension methods, like ToArray(), etc.

Table#

In LINQ to SQL, most of the time, the query works on (the model of) SQL data table:

1
Table<Product> source = database.Products; // Products table of Northwind database.
2
IQueryable<string> results = source.Where(product =>
3
                                            product.Category.CategoryName == "Beverages")
4
                                   .Select(product => product.ProductName);

The actual type of (the model of) Products table is Table:

1
[Database(Name = "Northwind")]
2
public partial class NorthwindDataContext : DataContext
3
{
4
    public Table<Product> Products
5
    {
6
        get
7
        {
8
            return this.GetTable<Product>();
9
        }
10
    }
11
}

And, Table implements IQueryable:

1
namespace System.Data.Linq
2
{
3
    public sealed class Table<TEntity> : IQueryable<TEntity>, IQueryable,
4
                                         IEnumerable<TEntity>, IEnumerable,
5
                                         ITable<TEntity>, ITable,
6
                                         IQueryProvider,
7
                                         IListSource
8
        where TEntity : class
9
    {
10
        // ...
11
    }
12
}

So all the above query methods are applicable for Table.

IEnumerable extensions vs. IQueryable extensions#

In the above table, two kinds of Where() extension methods are applicable for IQueryable:

• Where() extension method for IQueryable, defined in Queryable class;
• Where() extension method for IEnumerable, defind in Queryable class, since IQueryable implements IEnumerable.

They are difference from the signatures:

1
namespace System.Data.Linq
2
{
3
    public static class Enumerable
4
    {
5
        // This is also Available for IQueryable<T>,
6
        // because IQueryable<T> implements IEnumerable<T>.
7
        public static IEnumerable<TSource> Where<TSource>(
8
            this IEnumerable<TSource> source, Func<TSource, bool> predicate)
9
        {
10
            // ...
11
        }
12
    }
13

14
    public static class Queryable
15
    {
16
        public static IQueryable<TSource> Where<TSource>(
17
            this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
18
        {
19
            // ...
20
        }
21
    }
22
}

Please notice that the above Where() method invocation satisfies both of the signatures:

1
source.Where(product => product.Category.CategoryName == "Beverages").Select(...

In this invocation:

• source argument: it is a Table object, and Table implements both IQueryable and IEnumerable;
• predicate argument: The predicate is written as lambda expression, accorsing to this post, lambda expression (product => product.Category.CategoryName == “Beverages”) can be compiled into either anonymous method (Func<Product, bool>) or expression tree (Expression<Func<Product, bool>>).

How does the compiler choose the 2 satisfied Where() methods? Because Queryable.Where()’s first parameter is an IQueryable object, and second parameter is also Ok, it is considered to be a stronger match, and it is choosed by compiler.

Because Queryable.Where() returns an IQueryable, then, again, Queryable.Select() is choosed by compiler instead of Enumerable.Select().

So the above qeury is equal to:

1
IQueryable<Product> source = database.Products; // Products table of Northwind database.
2
// Queryable.Where() is choosed by compiler.
3
IQueryable<Product> products = source.Where(product =>
4
                                            product.Category.CategoryName == "Beverages");
5
// Queryable.Select() is choosed by compiler.
6
IQueryable<string> results = products.Select(product => product.ProductName);

By checking all the duplicated extension mrethods betwwen IEnumerable and IQueryable, IQueryable extension methods evolve the signatures by:

• replacing all IEnumerable parameter with IQueryable parameter;
• replacing all function parameter with expression tree parameter.

The expression tree parameter will be explained in the next post.