不可不知的表达式树（3）定制IQueryProvider

前面我们说到利用表达式树技术实现LINQ-to-SQL，实际上可以针对任何数据源，实现LINQ-to-Everything。这里还涉及到两个重要的接口即IQueryable和IQueryProvider，这些一起为实现通过LINQ访问各种数据源提供了统一的编程接口。

一、认识IQueryable<T>

接口源码如下：

namespace System.Linq
{
    //提供对未指定数据类型的特定数据源的查询进行计算的功能。
    public interface IQueryable : IEnumerable
    {
        //获取与 System.Linq.IQueryable 的实例关联的表达式树。
        Expression Expression { get; }
        //获取在执行与 System.Linq.IQueryable 的此实例关联的表达式树时返回的元素的类型。
        Type ElementType { get; }
        //获取与此数据源关联的查询提供程序。
        IQueryProvider Provider { get; }
    }
    public interface IQueryable<out T> : IEnumerable<T>, IQueryable, IEnumerable
    {
    }
}

 IQueryable中定义了三个只读的属性，ElementType即为查询对象的类型，Expression即为表达式树，我们的Linq查询表达式都将转换为表达式树，而Provider表示数据源查询提供程序，将Expression翻译为数据源的查询语言，如Sql，并负责最终的数据查询实现。所以我们必须要实现IQueryProvider接口。

二、IQueryProvider

接口源码如下：

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

IQueryProvider接口包含两组方法，CreateQuery顾名思义即是由Provider通过传入的Expression参数创建并返回一个新的IQueryable查询实例。

Execute则是真正解析Expression的，解析即遍历并翻译其为特定查询语言的过程，然后进行查询，并返回查询结果object。

三、定制IQueryProvider

定制查询我们自己的数据源，比如最终实现如下的代码调用方式，该如何实现呢？

class Program
    {
        static void Main(string[] args)
        {
            var provider = new MyQueryProvider();
            var queryable = new Query<Person>(provider);

            var query =
                from p in queryable
                where p.Age >= 18 &&
                p.Gender== “男” 
                select p;

            var list = query.ToList();
            Console.ReadLine();
        }
    }

下面先给出这段代码执行的时序图来帮助我们进一步理解整个执行过程：

代码5-6行，对应步骤1-4，实例化了我们自定义的IQueryable；

代码8-12行，对应步骤5-8，在IQueryable实例基础上，进行Linq查询，查询表达式翻译为Expression，构造出新的IQueryable实例；

代码14行，对应步骤9-12，ToList()方法调用，延迟加载执行，查询出结果并返回。

从中可以看出我们的类图大概是这样的：

大体框架就是如此，然后我们需要做的最重要的事情就是实现MyQueryProvider的Execute()，在这个核心方法里解析Expression，翻译为特定数据源的查询语句，并进行查询。

实例代码：

  public override object Execute(Expression expression)
  {
     //遍历表达式树，生成特定数据源的查询语句，例如sql
     String myLang = new MyExpressionVisitor().ProcessExpression(expression);
     //根据查询语句进行查询得到结果
     IEnumerable<Person> results = PersonHelper.DoQuery(myLang);
     return results;
  }

 

至于第6行代码，根据查询语句查询出结果，就是各种Helper的职责了，例如SqlHelper。

然后最重要的，还是ProcessExpression(expression)的实现了，换句话说归根结底这个IQueryProvider最核心的功能就是遍历表达式树。

最后给出主要的遍历代码：

    public class MyExpressionVisitor
    {
        private string _myLang;
        // 入口方法
        public string ProcessExpression(Expression expression)
        {
            _myLang = string.Empty;
            VisitExpression(expression);
            return _myLang;
        }
        private void VisitExpression(Expression expression)
        {
            switch (expression.NodeType)
            {
                // 访问 &&
                case ExpressionType.AndAlso:
                    VisitAndAlso((BinaryExpression)expression);
                    break;
                // 访问 等于
                case ExpressionType.Equal:
                    VisitEqual((BinaryExpression)expression);
                    break;
                // 访问 小于和小于等于
                case ExpressionType.LessThan:
                case ExpressionType.LessThanOrEqual:
                    VisitLessThanOrEqual((BinaryExpression)expression);
                    break;
                // 访问大于和大于等于
                case ExpressionType.GreaterThan:
                case ExpressionType.GreaterThanOrEqual:
                    GreaterThanOrEqual((BinaryExpression)expression);
                    break;
                // 访问调用方法，主要用于解析Contains方法
                case ExpressionType.Call:
                    VisitMethodCall((MethodCallExpression)expression);
                    break;
                // 访问Lambda表达式
                case ExpressionType.Lambda:
                    VisitExpression(((LambdaExpression)expression).Body);
                    break;
            }
        }

        // 访问  &&
        private void VisitAndAlso(BinaryExpression andAlso)
        {
            VisitExpression(andAlso.Left);
            VisitExpression(andAlso.Right);
        }

        // 访问 等于
        private void VisitEqual(BinaryExpression expression)
        {
            //...
        }

        // 访问大于等于
        private void GreaterThanOrEqual(BinaryExpression expression)
        {
            //...
        }

        // 访问 小于和小于等于
        private void VisitLessThanOrEqual(BinaryExpression expression)
        {
            //...
        }

        // 访问 方法调用
        private void VisitMethodCall(MethodCallExpression expression)
        {
            //...
        }

        // 获取属性值
        private Object GetMemberValue(MemberExpression memberExpression)
        {
            MemberInfo memberInfo;
            Object obj;

            if (memberExpression == null)
                throw new ArgumentNullException("memberExpression");


            if (memberExpression.Expression is ConstantExpression)
                obj = ((ConstantExpression)memberExpression.Expression).Value;
            else if (memberExpression.Expression is MemberExpression)
                obj = GetMemberValue((MemberExpression)memberExpression.Expression);
            else
                throw new NotSupportedException("Expression type not supported: "
                    + memberExpression.Expression.GetType().FullName);

            memberInfo = memberExpression.Member;
            if (memberInfo is PropertyInfo)
            {
                PropertyInfo property = (PropertyInfo)memberInfo;
                return property.GetValue(obj, null);
            }
            else if (memberInfo is FieldInfo)
            {
                FieldInfo field = (FieldInfo)memberInfo;
                return field.GetValue(obj);
            }
            else
            {
                throw new NotSupportedException("MemberInfo type not supported: "
                    + memberInfo.GetType().FullName);
            }
        }
    }

 

至此，表达式树系列文章完结，希望对大家有所帮助。

文章参考: The Wayward WebLog.