打造自己的LINQ Provider（上）：Expression Tree揭秘

本文首发博客园，作者TerryLee，原文地址：打造自己的LINQ Provider（上）：Expression Tree揭秘

概述

在.NET Framework 3.5中提供了LINQ 支持后，LINQ就以其强大而优雅的编程方式赢得了开发人员的喜爱，而各种LINQ Provider更是满天飞，如LINQ to NHibernate、LINQ to Google等，大有“一切皆LINQ”的趋势。LINQ本身也提供了很好的扩展性，使得我们可以轻松的编写属于自己的LINQ Provider。

本文为打造自己的LINQ Provider系列文章第一篇，主要介绍表达式目录树（Expression Tree）的相关知识。

认识表达式目录树

究竟什么是表达式目录树（Expression Tree），它是一种抽象语法树或者说它是一种数据结构，通过解析表达式目录树，可以实现我们一些特定的功能（后面会说到），我们首先来看看如何构造出一个表达式目录树，最简单的方法莫过于使用Lambda表达式，看下面的代码：

Expression<Func<int, int, int>> expression = (a, b) => a * b + 2;

在我们将Lambda表达式指定给Expression<TDelegate>类型的变量（参数）时，编译器将会发出生成表达式目录树的指令，如上面这段代码中的Lambda表达式(a, b) => a * b + 2将创建一个表达式目录树，它表示的是一种数据结构，即我们把一行代码用数据结构的形式表示了出来，具体来说最终构造出来的表达式目录树形状如下图所示：

这里每一个节点都表示一个表达式，可能是一个二元运算，也可能是一个常量或者参数等，如上图中的ParameterExpression就是一个参数表达式，ConstantExpression是一个常量表达式，BinaryExpression是一个二元表达式。我们也可以在Visual Studio中使用Expression Tree Visualizer来查看该表达式目录树：

查看结果如下图所示：

这里说一句，Expression Tree Visualizer可以从MSDN Code Gallery上的LINQ Sample中得到。现在我们知道了表达式目录树的组成，来看看.NET Framework到底提供了哪些表达式？如下图所示：

它们都继承于抽象的基类Expression，而泛型的Expression<TDelegate>则继承于LambdaExpression。在Expression类中提供了大量的工厂方法，这些方法负责创建以上各种表达式对象，如调用Add()方法将创建一个表示不进行溢出检查的算术加法运算的BinaryExpression对象，调用Lambda方法将创建一个表示lambda 表达式的LambdaExpression对象，具体提供的方法大家可以查阅MSDN。上面构造表达式目录树时我们使用了Lambda表达式，现在我们看一下如何通过这些表达式对象手工构造出一个表达式目录树，如下代码所示：

static void Main(string[] args)
{
    ParameterExpression paraLeft = Expression.Parameter(typeof(int), "a");
    ParameterExpression paraRight = Expression.Parameter(typeof(int), "b");
    BinaryExpression binaryLeft = Expression.Multiply(paraLeft, paraRight);
    ConstantExpression conRight = Expression.Constant(2, typeof(int));
    BinaryExpression binaryBody = Expression.Add(binaryLeft, conRight);
    LambdaExpression lambda = 
        Expression.Lambda<Func<int, int, int>>(binaryBody, paraLeft, paraRight);
    Console.WriteLine(lambda.ToString());
    Console.Read();
}

这里构造的表达式目录树，仍然如下图所示：

运行这段代码，看看输出了什么：

  

可以看到，通过手工构造的方式，我们确实构造出了同前面一样的Lambda表达式。对于一个表达式目录树来说，它有几个比较重要的属性：

Body：指表达式的主体部分；

Parameters：指表达式的参数；

NodeType：指表达式的节点类型，如在上面的例子中，它的节点类型是Lambda；

Type：指表达式的静态类型，在上面的例子中，Type为Fun<int,int,int>。

在Expression Tree Visualizer中，我们可以看到表达式目录树的相关属性，如下图所示：

 

表达式目录树与委托

大家可能经常看到如下这样的语言，其中第一句是直接用Lambda表达式来初始化了Func委托，而第二句则使用Lambda表达式来构造了一个表达式目录树，它们之间的区别是什么呢？

static void Main(string[] args)
{
    Func<int, int, int> lambda = (a, b) => a + b * 2;
    Expression<Func<int, int, int>> expression = (a, b) => a + b * 2;
} 

其实看一下IL就很明显，其中第一句直接将Lambda表达式直接编译成了IL，如下代码所示：

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  .maxstack  3
  .locals init ([0] class [System.Core]System.Func`3<int32,int32,int32> lambda)
  IL_0000:  nop
  IL_0001:  ldsfld     class [System.Core]System.Func`3<int32,int32,int32> 
                        TerryLee.LinqToLiveSearch.Program::'CS$<>9__CachedAnonymousMethodDelegate1'
  IL_0006:  brtrue.s   IL_001b
  IL_0008:  ldnull
  IL_0009:  ldftn      int32 TerryLee.LinqToLiveSearch.Program::'<Main>b__0'(int32,
                                                                             int32)
  IL_000f:  newobj     instance void class [System.Core]System.Func`3<int32,int32,int32>::.ctor(object,
                                                                                                native int)
  IL_0014:  stsfld     class [System.Core]System.Func`3<int32,int32,int32> 
                    TerryLee.LinqToLiveSearch.Program::'CS$<>9__CachedAnonymousMethodDelegate1'
  IL_0019:  br.s       IL_001b
  IL_001b:  ldsfld     class [System.Core]System.Func`3<int32,int32,int32> 
                    TerryLee.LinqToLiveSearch.Program::'CS$<>9__CachedAnonymousMethodDelegate1'
  IL_0020:  stloc.0
  IL_0021:  ret
}

而第二句，由于告诉编译器是一个表达式目录树，所以编译器会分析该Lambda表达式，并生成表示该Lambda表达式的表达式目录树，即它与我们手工创建表达式目录树所生成的IL是一致的，如下代码所示，此处为了节省空间省略掉了部分代码：

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  .maxstack  4
  .locals init ([0] class [System.Core]System.Linq.Expressions.Expression`1<
                class [System.Core]System.Func`3<int32,int32,int32>> expression,
           [1] class [System.Core]System.Linq.Expressions.ParameterExpression CS$0$0000,
           [2] class [System.Core]System.Linq.Expressions.ParameterExpression CS$0$0001,
           [3] class [System.Core]System.Linq.Expressions.ParameterExpression[] CS$0$0002)
  IL_0000:  nop
  IL_0001:  ldtoken    [mscorlib]System.Int32
  IL_0006:  call       class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(...)
  IL_000b:  ldstr      "a"
  IL_0010:  call       class [System.Core]System.Linq.Expressions.ParameterExpression 
                        [System.Core]System.Linq.Expressions.Expression::Parameter(
                        class [mscorlib]System.Type,
  IL_0038:  call    class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle()
  IL_003d:  call    class [System.Core]System.Linq.Expressions.ConstantExpression 
                    [System.Core]System.Linq.Expressions.Expression::Constant(object,
                    class [mscorlib]System.Type)
  IL_0042:  call    class [System.Core]System.Linq.Expressions.BinaryExpression 
                    [System.Core]System.Linq.Expressions.Expression::Multiply(class [System.Core]System.Linq.Expressions.Expression,
                    class [System.Core]System.Linq.Expressions.Expression)
  IL_0047:  call    class [System.Core]System.Linq.Expressions.BinaryExpression
                    [System.Core]System.Linq.Expressions.Expression::Add(class [System.Core]System.Linq.Expressions.Expression,
                    class [System.Core]System.Linq.Expressions.Expression)
  IL_004c:  ldc.i4.2
  IL_004d:  newarr     [System.Core]System.Linq.Expressions.ParameterExpression
}

现在相信大家都看明白了，这里讲解它们的区别主要是为了加深大家对于表达式目录树的区别。

执行表达式目录树

前面已经可以构造出一个表达式目录树了，现在看看如何去执行表达式目录树。我们需要调用Compile方法来创建一个可执行委托，并且调用该委托，如下面的代码：

static void Main(string[] args)
{
    ParameterExpression paraLeft = Expression.Parameter(typeof(int), "a");
    ParameterExpression paraRight = Expression.Parameter(typeof(int), "b");
    BinaryExpression binaryLeft = Expression.Multiply(paraLeft, paraRight);
    ConstantExpression conRight = Expression.Constant(2, typeof(int));
    BinaryExpression binaryBody = Expression.Add(binaryLeft, conRight);
    Expression<Func<int, int, int>> lambda = 
        Expression.Lambda<Func<int, int, int>>(binaryBody, paraLeft, paraRight);
    Func<int, int, int> myLambda = lambda.Compile();
    int result = myLambda(2, 3);
    Console.WriteLine("result:" + result.ToString());
    Console.Read();
}

运行后输出的结果：

这里我们只要简单的调用Compile方法就可以了，事实上在.NET Framework中是调用了一个名为ExpressionCompiler的内部类来做表达式目录树的执行（注意此处的Compiler不等同于编译器的编译）。另外，只能执行表示Lambda表达式的表达式目录树，即LambdaExpression或者Expression<TDelegate>类型。如果表达式目录树不是表示Lambda表达式，需要调用Lambda方法创建一个新的表达式。如下面的代码：

static void Main(string[] args)
{
    BinaryExpression body = Expression.Add(
        Expression.Constant(2),
        Expression.Constant(3));
    Expression<Func<int>> expression = 
        Expression.Lambda<Func<int>>(body, null);
    Func<int> lambda = expression.Compile();
    Console.WriteLine(lambda());
}

访问与修改表达式目录树

在本文一开始我就说过， 通过解析表达式目录树，我们可以实现一些特定功能，既然要解析表达式目录树，对于表达式目录树的访问自然是不可避免的。在.NET Framework中，提供了一个抽象的表达式目录树访问类ExpressionVisitor，但它是一个internal的，我们不能直接访问。幸运的是，在MSDN中微软给出了ExpressionVisitor类的实现，我们可以直接拿来使用。该类是一个抽象类，微软旨在让我们在集成ExpressionVisitor的基础上，实现自己的表达式目录树访问类。现在我们来看简单的表达式目录树：

static void Main(string[] args)
{
    Expression<Func<int, int, int>> lambda = (a, b) => a + b * 2;
    Console.WriteLine(lambda.ToString());
} 

输出后为：

现在我们想要修改表达式目录树，让它表示的Lambda表达式为(a,b)=>(a - (b * 2))，这时就需要编写自己的表达式目录树访问器，如下代码所示：

public class OperationsVisitor : ExpressionVisitor
{
    public Expression Modify(Expression expression)
    {
        return Visit(expression);
    }
    protected override Expression VisitBinary(BinaryExpression b)
    {
        if (b.NodeType == ExpressionType.Add)
        {
            Expression left = this.Visit(b.Left);
            Expression right = this.Visit(b.Right);
            return Expression.Subtract(left,right);
        }
        return base.VisitBinary(b);
    }
}

使用表达式目录树访问器来修改表达式目录树，如下代码所示：

static void Main(string[] args)
{
    Expression<Func<int, int, int>> lambda = (a, b) => a + b * 2;
    var operationsVisitor = new OperationsVisitor();
    Expression modifyExpression = operationsVisitor.Modify(lambda);
    Console.WriteLine(modifyExpression.ToString());
}

运行后可以看到输出：

似乎我们是修改表达式目录树，其实也不全对，我们只是修改表达式目录树的一个副本而已，因为表达式目录树是不可变的，我们不能直接修改表达式目录树，看看上面的OperationsVisitor类的实现大家就知道了，在修改过程中复制了表达式目录树的节点。

为什么需要表达式目录树

通过前面的介绍，相信大家对于表达式目录树已经有些了解了，还有一个很重要的问题，就是为什么需要表达式目录树？在本文开始时，就说过通过解析表达式目录树，可以实现我们一些特定的功能，就拿LINQ to SQL为例，看下面这幅图：

当我们在C#语言中编写一个查询表达式时，它将返回一个IQueryable类型的值，在该类型中包含了两个很重要的属性Expression和Provider，如下面的代码：

我们编写的查询表达式，将封装为一种抽象的数据结构，这个数据结构就是表达式目录树，当我们在使用上面返回的值时，编译器将会以该值所期望的方式进行翻译，这种方式就是由Expression和Provider来决定。可以看到，这样将会非常的灵活且具有良好的可扩展性，有了表达式目录树，可以自由的编写自己的Provider，去查询我们希望的数据源。经常说LINQ为访问各种不同的数据源提供了一种统一的编程方式，其奥秘就在这里。然而需要注意的是LINQ to Objects并不需要任何特定的LINQ Provider，因为它并不翻译为表达式目录树，后面会说到这一点。

总结

本文详细介绍了表达式目录树的相关知识，为我们编写自己的LINQ Provider打下一个基础，希望对于大家有所帮助。查看目前网上的各种lINQ Provider，请访问万般皆LINQ。

本文首发博客园，作者TerryLee，原文地址：打造自己的LINQ Provider（上）：Expression Tree揭秘

• 赞
• 收藏
• 评论
• 分享
• 举报

上一篇：技巧：在Silverlight应用程序中进行数据验证

下一篇：谈谈Silverlight 2中的视觉状态管理 Part2

提问和评论都可以，用心的回复会被更多人看到 评论

发布评论

全部评论 () 最热 最新

相关文章

• [转]打造自己的LINQ Provider（上）：Expression Tree揭秘

  概述在.NET Framework 3.5中提供了LINQ 支持后，LINQ就以其强大而优雅的编程方式赢得了开发人员的喜爱，而各种LINQ Provider更是满天飞，如LINQ to NHibernate、LINQ to Google等，大有“一切皆LINQ”的趋势。LINQ本身也提供了很好的扩展性，使得我们可以轻松的编写属于自己的LINQ Provider。本文为打造自己的LINQ Provi

  LINQ Provider Expression Tree 目录树 lambda表达式 ide
• 打造自己的LINQ Provider（中）：IQueryable和IQueryProvider

  在.NET Framework 3.5中提供了LINQ 支持后，LINQ就以其强大而优雅的编程方式赢得了开发人员的喜爱，而各种LINQ Provider更是满天飞，如LINQ to NHibernate、LINQ to Google等，大有“一切皆LINQ”的趋势。LINQ本身也提供了很好的扩展性，使得我们可以轻松的编写属于自己的LINQ Provider。 本文为打造自己的LINQ Provider系列文章第二篇，主要详细介绍自定义LINQ Provider中两个最重要的接口IQueryable和IQueryProvider。

  LINQ Expression Query Provider Tree
• Linq 之Expression Tree再思考

  一、   Expression Tree执行在执行表达式目录树之前，需要了解Expression命名空间的相关信息。该空间包含了构建Expression的类型，接口和枚举。抽象类Expression则提供用于表达式目录树架构的根节点。Expression命名空间主要包含了以下类型：    老赵在《扩展LINQ to SQL：使用Lambda Expres

  职场 C# 休闲 Linq
• LINQ Expression AndAlso，OrElse和And，Or的区别

  AndAlso和OrElse应该是vb。net引入的新运算符。因为用vb。net的时间还不是很长，之前我一直以为他们和and，or根本没有区别。现在终于明白，他们之间还是有很大区别的：AndAlso，OrElse相对于and，or最大的特性是会自动实现“最短路径”。所谓“最短路径”就是指：当第一个被

  其他
• 表达式树(Expression Tree)

  上一文中介绍了语句Lambda和表达式Lambda，关于语句Lambda没有什么好说的地方，关于表达式Lambda 可以说是大有文章，本着来详细的说一说 表达式树。

  表达式树 lambda表达式 编译器 可执行 类型变量
• 揭秘ChatGPT，如何打造自己的自定义指令 | 京东云技术团队

  在大语言模型的训练中，经常会看到 Instruct Tuning（指令微调）这个单词，GPT家族中也有一个 InstructGPT的模型（指令微调后的GPT），通过指令微调的LLM会更按照我们期望的方式输出

  官网 语言模型 解决方案 自定义指令
• Howto create a System.Linq.Expressions.Expression for Like

  http://stackoverflow.com/questions/956743/howto-create-a-system-linq-expressions-expression-for-likehttp://trentacular.com/2010/08/linq-to-entities-wild-card-like-extension-method/http://www.albahari.com/nutshell/predicatebuilder.aspx6 down vote accepted Something like:static IEnumerable<T> Wh

  数据
• 打造自己的音乐小程序（上）——主框架设计

  文章目录效果展示系统设计代码模块index.wxml效果展示 音乐小程序 系统设计程序主页面，其中包括header content footer 三大部分header 是tab栏，用于切换页面content 有 主页面信息，音乐播放器，播放列表三部分构成info：play：playlist：footer 是播放器，用于点击播放，切歌，查看列表，查看播放。代码模

  小程序 微信小程序 小程序开发
• 打造自己的鼠标右键

  以下问价存放位置均为c:\reg文件夹下 &#160; 1.新建任意类型文件 注册表文件 AnyType.reg Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.atef] @="AnyType_EggFile" [HKEY_LOCAL_MACHINE\

  职场 鼠标 休闲
• 打造属于自己的FTP

  打造属于自己的FTP作者：万敏基于2K.2003可以直接添加IIS服务来架设自己的FTP服务器，但XP下本人试过用IIS服务来架设，但并没有成功，XP系统已成为主流，下面通过软件来实现打造自己的FTP服务器。将下载到的Serv-U直接运行即可，一路"Next"也是大家习以为常的了。然而当我们第一次运行Serv-U时，程序会自动执行Wizard（设置向导），这对于

  职场 服务器 网络技术 休闲 FT[P
• vim:打造自己的ide

  vim:打造自己的ide作为技术宅，总有那么点强迫症，虽然网上各种现成的配置一大堆，还是觉得自己从零开始打造一个ide比较爽。花了几天时间，在配置的过程中逐渐熟悉了vim的使用，以及vim插件管理，也意识到，原来这么一个简单的ide居然集成了这么多插件。不得不感叹，哪些做ide的有多强。基本介绍vim8 + Vundle 管理各种插件。基本实现，语法高亮、代码提示补全、注释、函数定义和调用跳转、

  vim python git
• Expression Tree Build

  The structure of Expression Tree is a binary tree to evaluate certain expressions.All leaves of the Expression Tree have an number string value. All n

  压栈 i++ lua JAVA
• Evaluation of Expression Tree

  Evaluation of Expression Tree <!-- .entry-header --> Given a simple expression tree, consisting of basic binary operators i.e., + , – ,* and / and som

  tree lua #include ios c++
• Expression Tree 遍历集合

  场景 从接口返回的数据是集合，却是 object 类型的。这个时候需要遍历这个集合。现提供两种方法。 方法一： 因为集合是可枚举的，所以可以尝试转为 IEnumerable 类型，然后遍历即可。 static void Main(string[] args) { var list = new Lis ...

  ExpressionTree C# json 表达式树 回调函数
• Get Argument Values From Linq Expression

  Get Argument Values From Linq Expression If you even find yourself unpacking an expression in C#, you might find this useful. I found myself in need o

  c#
• LINQ 表达式树 Expression

  在 LINQ to Objects 中，扩展方法需要将一个委托类型作为参数，这样就可以将λ表达式赋予参数。 λ达式也可以赋予Expression<T>类型的参数。Expression<T>类型指定，来自于λ表达式的表达式树存储在程序集中。 这样，就可以在运行期间分析表达式，并进行优化，以便于查询数据源。 下面看看一个前面使用的查询表达式： var brazilRace...

  表达式树 扩展方法 程序集 查询表达式 数据源
• LINQ的Expression与delegate表达式

  Linq的delegate表达式，Insus.NET觉得它封装得好，让开发时简化了很多代码，而且容易阅读与检索。 比如，我们需要计算优惠给客户金额，打85%折，可以这样写： using System; using System.Collections.Generic; using System.Li

  delegate linq Expression Compile Lambda
• Traverse an expression tree and extract parameters

  Traverse an expression tree and extract parameters I think as you've said that using ExpressionVisitor works out to be a good approach. You don't need

  ide sed
• 关于Expression Tree和IL Emit的所谓的

  昨天写了《三种属性操作性能比较》，有个网友写信问我一个问题：从性能上看，Expression Tree和IL Emit孰优孰劣?虽然我在回信中作了简单的回答，但不知道这个网友是否懂我的意思。反正今天呆在家里也没事儿，干脆再就这个话题再写一篇文章。 有个网友写信问我一个问题：从性能上看，Expression Tree和IL Emit孰优孰劣?虽然我在回信中作了简单的回答，但不知道这个网友是

  IL Emit Expression Tree 赋值 取值 静态方法