LINQ:创建IQueryable Provider<1>

public interface IQueryable : IEnumerable
{
Type ElementType { get; }
Expression Expression { get; }
IQueryProvider Provider { get; }
}
public interface IQueryable<T> : IEnumerable<T>, IQueryable, IEnumerable
{
}

public interface IQueryProvider {
IQueryable CreateQuery(Expression expression);
IQueryable<TElement> CreateQuery<TElement>(Expression expression);
object Execute(Expression expression);
TResult Execute<TResult>(Expression expression);
}

看到这个接口你可以看到它实际上只有两个操作符：CreateQuery和Execute，只不过提供了泛型和非泛型两种实现。

CreateQuery方法通过特定的ExpressionTree创建一个新的IQueryable查询实例。

Execute方法是真正执行查询表达式的Provider的入口。

public class Query<T> : IQueryable<T>, IQueryable, IEnumerable<T>, IEnumerable, IOrderedQueryable<T>, IOrderedQueryable {
QueryProvider provider;
Expression expression;

public Query(QueryProvider provider) {
if (provider == null) {
throw new ArgumentNullException("provider");
}
this.provider = provider;
this.expression = Expression.Constant(this);
}

public Query(QueryProvider provider, Expression expression) {
if (provider == null) {
throw new ArgumentNullException("provider");
}
if (expression == null) {
throw new ArgumentNullException("expression");
}
if (!typeof(IQueryable<T>).IsAssignableFrom(expression.Type)) {
throw new ArgumentOutOfRangeException("expression");
}
this.provider = provider;
this.expression = expression;
}

Expression IQueryable.Expression {
get { return this.expression; }
}

Type IQueryable.ElementType {
get { return typeof(T); }
}

IQueryProvider IQueryable.Provider {
get { return this.provider; }
}

public IEnumerator<T> GetEnumerator() {
return ((IEnumerable<T>)this.provider.Execute(this.expression)).GetEnumerator();
}

IEnumerator IEnumerable.GetEnumerator() {
return ((IEnumerable)this.provider.Execute(this.expression)).GetEnumerator();
}

public override string ToString() {
return this.provider.GetQueryText(this.expression);
}
}
IQueryable实现很浅显，仅仅是持有一个Expression Tree和Provider。

接下来我们提供一些Provider的实现，我先实现一个抽象基类，真正的Provider都可以从这个类派生而来。

public abstract class QueryProvider : IQueryProvider {
protected QueryProvider() {
}

IQueryable<S> IQueryProvider.CreateQuery<S>(Expression expression) {
return new Query<S>(this, expression);
}

IQueryable IQueryProvider.CreateQuery(Expression expression) {
Type elementType = TypeSystem.GetElementType(expression.Type);
try {
return (IQueryable)Activator.CreateInstance(typeof(Query<>).MakeGenericType(elementType), new object[] { this, expression });
}
catch (TargetInvocationException tie) {
throw tie.InnerException;
}
}

S IQueryProvider.Execute<S>(Expression expression) {
return (S)this.Execute(expression);
}

object IQueryProvider.Execute(Expression expression) {
return this.Execute(expression);
}

public abstract string GetQueryText(Expression expression);
public abstract object Execute(Expression expression);
}

还有一个辅助类：

internal static class TypeSystem {
internal static Type GetElementType(Type seqType) {
Type ienum = FindIEnumerable(seqType);
if (ienum == null) return seqType;
return ienum.GetGenericArguments()[0];
}
private static Type FindIEnumerable(Type seqType) {
if (seqType == null || seqType == typeof(string))
return null;
if (seqType.IsArray)
return typeof(IEnumerable<>).MakeGenericType(seqType.GetElementType());
if (seqType.IsGenericType) {
foreach (Type arg in seqType.GetGenericArguments()) {
Type ienum = typeof(IEnumerable<>).MakeGenericType(arg);
if (ienum.IsAssignableFrom(seqType)) {
return ienum;
}
}
}
Type[] ifaces = seqType.GetInterfaces();
if (ifaces != null && ifaces.Length > 0) {
foreach (Type iface in ifaces) {
Type ienum = FindIEnumerable(iface);
if (ienum != null) return ienum;
}
}
if (seqType.BaseType != null && seqType.BaseType != typeof(object)) {
return FindIEnumerable(seqType.BaseType);
}
return null;
}
}

真正的动作在Execute中执行，只有在这里才会执行Expression Tree。我们在下一节中再说。